evolvedbinary / elemental / 982

Committed 29 Apr 2025 08:34PM UTC coverage: 56.409% (+0.007%) from 56.402%

Build # 982

Build Type

push

circleci

Committed by

adamretter

Commit Message

[feature] Improve README.md badges

Run Details

28451 of 55847 branches covered (50.94%)

Branch coverage included in aggregate %.

77468 of 131924 relevant lines covered (58.72%)

0.59 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.76

/exist-core/src/main/java/org/exist/xquery/functions/fn/FunParseIetfDate.java

/*
 * Elemental
 * Copyright (C) 2024, Evolved Binary Ltd
 *
 * admin@evolvedbinary.com
 * https://www.evolvedbinary.com | https://www.elemental.xyz
 *
 * Use of this software is governed by the Business Source License 1.1
 * included in the LICENSE file and at www.mariadb.com/bsl11.
 *
 * Change Date: 2028-04-27
 *
 * On the date above, in accordance with the Business Source License, use
 * of this software will be governed by the Apache License, Version 2.0.
 *
 * Additional Use Grant: Production use of the Licensed Work for a permitted
 * purpose. A Permitted Purpose is any purpose other than a Competing Use.
 * A Competing Use means making the Software available to others in a commercial
 * product or service that: substitutes for the Software; substitutes for any
 * other product or service we offer using the Software that exists as of the
 * date we make the Software available; or offers the same or substantially
 * similar functionality as the Software.
 *
 * NOTE: Parts of this file contain code from 'The eXist-db Authors'.
 *       The original license header is included below.
 *
 * =====================================================================
 *
 * eXist-db Open Source Native XML Database
 * Copyright (C) 2001 The eXist-db Authors
 *
 * info@exist-db.org
 * http://www.exist-db.org
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
package org.exist.xquery.functions.fn;

import org.exist.dom.QName;
import org.exist.xquery.*;
import org.exist.xquery.value.*;

import javax.xml.datatype.DatatypeConstants;
import javax.xml.datatype.XMLGregorianCalendar;

import java.math.BigDecimal;
import java.math.BigInteger;

import java.util.Map;
import java.util.HashMap;
import java.util.Arrays;

import static org.exist.util.StringUtil.startsWith;

/**
 * Parses a string containing the date and time in IETF format,
 * returning the corresponding xs:dateTime value.
 *
 * @author Juri Leino (juri@existsolutions.com)
 */
public class FunParseIetfDate extends BasicFunction {

    private static FunctionParameterSequenceType IETF_DATE =
            new FunctionParameterSequenceType(
                    "value", Type.STRING, Cardinality.ZERO_OR_ONE, "The IETF-dateTime string");

    private static FunctionReturnSequenceType RETURN =
            new FunctionReturnSequenceType(
                    Type.DATE_TIME, Cardinality.ZERO_OR_ONE, "The parsed date");


    public final static FunctionSignature FNS_PARSE_IETF_DATE = new FunctionSignature(
            new QName("parse-ietf-date", Function.BUILTIN_FUNCTION_NS),
            "Parses a string containing the date and time in IETF format,\n" +
                    "returning the corresponding xs:dateTime value.",
            new SequenceType[]{IETF_DATE},
            RETURN
    );

    public FunParseIetfDate(XQueryContext context, FunctionSignature signature) {
        super(context, signature);
    }

    @Override
    public Sequence eval(Sequence[] args, Sequence contextSequence) throws XPathException {
        if (args[0].isEmpty()) {
            return Sequence.EMPTY_SEQUENCE;
        }
        final String value = args[0].getStringValue();
        final Parser p = new Parser(value.trim());

        try {
            return new DateTimeValue(this, p.parse());
        } catch (final IllegalArgumentException i) {
            throw new XPathException(this, ErrorCodes.FORG0010, "Invalid Date time " + value, i);
        }
    }

    private class Parser {
        private final char[] WS = {0x000A, 0x0009, 0x000D, 0x0020};
        private final String WS_STR = new String(WS);

        private final String[] dayNames = {
                "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun",
                "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"
        };

        private final String[] monthNames = {
                "Jan", "Feb", "Mar", "Apr", "May", "Jun",
                "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
        };

        private final String[] tzNames = {
                "UT", "UTC", "GMT", "EST", "EDT", "CST", "CDT", "MST", "MDT", "PST", "PDT"
        };

        private final Map<String, Integer> TZ_MAP = initMap();
        private final String value;
        private final int vlen;
        private int vidx;

        private BigInteger year = null;
        private int month = DatatypeConstants.FIELD_UNDEFINED;
        private int day = DatatypeConstants.FIELD_UNDEFINED;

        private int hour = DatatypeConstants.FIELD_UNDEFINED;
        private int minute = DatatypeConstants.FIELD_UNDEFINED;
        private int second = DatatypeConstants.FIELD_UNDEFINED;
        private BigDecimal fractionalSecond = null;

        private int timezone = DatatypeConstants.FIELD_UNDEFINED;

        private Parser(String value) {
            this.value = value;
            this.vlen = value.length();
        }

        private Map<String, Integer> initMap() {
            Map<String, Integer> result = new HashMap<>();
            result.put("UT", 0);
            result.put("UTC", 0);
            result.put("GMT", 0);
            result.put("EST", -5);
            result.put("EDT", -4);
            result.put("CST", -6);
            result.put("CDT", -5);
            result.put("MST", -7);
            result.put("MDT", -6);
            result.put("PST", -8);
            result.put("PDT", -7);
            return result;
        }

        /**
         * <p>Parse a formatted <code>String</code> into an <code>XMLGregorianCalendar</code>.</p>
         * <p>
         * <p>If <code>String</code> is not formatted as a legal <code>IETF Date</code> value,
         * an <code>IllegalArgumentException</code> is thrown.</p>
         * <pre>
         * input        ::=        (dayname ","? S)? ((datespec S time) | asctime)
         * datespec        ::=        daynum dsep monthname dsep year
         * dsep        ::=        S | (S? "-" S?)
         * daynum        ::=        digit digit?
         * year        ::=        digit digit (digit digit)?
         * digit        ::=        [0-9]
         * time        ::=        hours ":" minutes (":" seconds)? (S? timezone)?
         * hours        ::=        digit digit?
         * minutes        ::=        digit digit
         * seconds        ::=        digit digit ("." digit+)?
         * S ::= (x0A|x09|x0D|x20)+
         * </pre>
         *
         * @throws IllegalArgumentException If <code>String</code> is not formatted as a legal <code>IETF Date</code> value.
         */
        public XMLGregorianCalendar parse() throws IllegalArgumentException {
            dayName();
            dateSpec();
            if (vidx != vlen) {
                throw new IllegalArgumentException(value);
            }
            return TimeUtils
                    .getInstance()
                    .getFactory()
                    .newXMLGregorianCalendar(year, month, day, hour, minute, second, fractionalSecond, timezone);
        }

        private void dayName() {
            if (startsWith(value, dayNames)) {
                skipTo(WS_STR);
                vidx++;
            }
        }

        private void dateSpec() throws IllegalArgumentException {
            if (isWS(peek())) {
                skipWS();
            }
            if (startsWith(value.substring(vidx), monthNames)) {
                asctime();
            } else {
                rfcDate();
            }
        }

        private void rfcDate() throws IllegalArgumentException {
            day();
            dsep();
            month();
            dsep();
            year();
            skipWS();
            time();
        }

        private void asctime() throws IllegalArgumentException {
            month();
            dsep();
            day();
            skipWS();
            time();
            skipWS();
            year();
        }

        private void year() throws IllegalArgumentException {
            final int vstart = vidx;

            while (isDigit(peek())) {
                vidx++;
            }
            final int digits = vidx - vstart;
            String yearString;
            if (digits == 2) {
                yearString = "19" + value.substring(vstart, vidx);
            } else if (digits == 4) {
                yearString = value.substring(vstart, vidx);
            } else {
                throw new IllegalArgumentException(value);
            }

            year = new BigInteger(yearString);
        }

        private void month() throws IllegalArgumentException {
            final int vstart = vidx;
            vidx += 3;
            if (vidx >= vlen) {
                throw new IllegalArgumentException(value);
            }
            final String monthName = value.substring(vstart, vidx);
            final int idx = Arrays.asList(monthNames).indexOf(monthName);
            if (idx < 0) {
                throw new IllegalArgumentException(value);
            }
            month = idx + 1;
        }

        private void day() throws IllegalArgumentException {
            day = parseInt(1, 2);
        }

        private void time() throws IllegalArgumentException {
            hours();
            minutes();
            seconds();
            skipWS();
            timezone();
        }

        private void hours() throws IllegalArgumentException {
            hour = parseInt(2, 2);
        }

        private void minutes() throws IllegalArgumentException {
            skip(':');
            minute = parseInt(2, 2);
            checkMinutes(minute);
        }

        private void seconds() throws IllegalArgumentException {
            if (isWS(peek())) {
                second = 0;
                return;
            }
            skip(':');
            second = parseInt(2, 2);
            fractionalSecond = parseBigDecimal();
        }

        private void timezone() throws IllegalArgumentException {
            if (!startsWith(value.substring(vidx), tzNames)) {
                tzoffset();
                return;
            }
            parseTimezoneName();
        }

        private void parseTimezoneName() {
            final int vstart = vidx;
            while (isUpperCaseLetter(peek())) {
                vidx++;
            }
            final String tzName = value.substring(vstart, vidx);
            if (!TZ_MAP.containsKey(tzName)) {
                throw new IllegalArgumentException(value);
            }
            timezone = TZ_MAP.get(tzName) * 60;
        }

        private void tzoffset() throws IllegalArgumentException {
            final char sign = peek();
            if (!(sign == '+' || sign == '-')) {
                throw new IllegalArgumentException(value);
            }

            vidx++;
            final int h = parseInt(1, 2);

            if (peek() == ':') {
                skip(':');
            }

            int m = 0;
            if (isDigit(peek())) {
                m = parseInt(2, 2);
            }
            checkMinutes(m);

            final int offset = h * 60 + m;
            final int factor = (sign == '+' ? 1 : -1);
            timezone = offset * factor;

            // cut off whitespace and optional timezone in parenthesis
            if (isWS(peek()) || peek() == '(') {
                vidx = vlen;
            }
        }

        private void dsep() throws IllegalArgumentException {
            if (isWS(peek())) {
                skipWS();
            }
            if (peek() != '-') {
                return;
            }
            skip('-');
            if (isWS(peek())) {
                skipWS();
            }
        }

        private void skipWS() throws IllegalArgumentException {
            if (!isWS(peek())) {
                throw new IllegalArgumentException(value);
            }

            while (isWS(peek())) {
                vidx++;
            }
        }

        private char peek() {
            if (vidx == vlen) {
                return (char) -1;
            }
            return value.charAt(vidx);
        }

        private char read() throws IllegalArgumentException {
            if (vidx == vlen) {
                throw new IllegalArgumentException(value);
            }
            return value.charAt(vidx++);
        }

        private void skipTo(String sequence) throws IllegalArgumentException {
            while (sequence.indexOf(peek()) < 0) {
                read();
            }
        }

        private void skip(char ch) throws IllegalArgumentException {
            if (read() != ch) throw new IllegalArgumentException(value);
        }

        private int parseInt(int minDigits, int maxDigits) throws IllegalArgumentException {
            final int vstart = vidx;
            while (isDigit(peek()) && (vidx - vstart) < maxDigits) {
                vidx++;
            }
            if ((vidx - vstart) < minDigits) {
                // we are expecting more digits
                throw new IllegalArgumentException(value);
            }

            return Integer.parseInt(value.substring(vstart, vidx));
        }

        private BigDecimal parseBigDecimal() throws IllegalArgumentException {
            final int vstart = vidx;

            if (peek() == '.') {
                vidx++;
            } else {
                return new BigDecimal("0");
            }
            while (isDigit(peek())) {
                vidx++;
            }
            return new BigDecimal(value.substring(vstart, vidx));
        }

        private void checkMinutes(int m) {
            if (m >= 60 || m < 0) {
                throw new IllegalArgumentException(value);
            }
        }

        private boolean isWS(char c) {
            return (WS_STR.indexOf(c) >= 0);
        }

        private boolean isDigit(char ch) {
            return '0' <= ch && ch <= '9';
        }

        private boolean isUpperCaseLetter(char ch) {
            return 'A' <= ch && ch <= 'Z';
        }
    }
}

1	/*
2	* Elemental
3	* Copyright (C) 2024, Evolved Binary Ltd
4	*
5	* admin@evolvedbinary.com
6	* https://www.evolvedbinary.com \| https://www.elemental.xyz
7	*
8	* Use of this software is governed by the Business Source License 1.1
9	* included in the LICENSE file and at www.mariadb.com/bsl11.
10	*
11	* Change Date: 2028-04-27
12	*
13	* On the date above, in accordance with the Business Source License, use
14	* of this software will be governed by the Apache License, Version 2.0.
15	*
16	* Additional Use Grant: Production use of the Licensed Work for a permitted
17	* purpose. A Permitted Purpose is any purpose other than a Competing Use.
18	* A Competing Use means making the Software available to others in a commercial
19	* product or service that: substitutes for the Software; substitutes for any
20	* other product or service we offer using the Software that exists as of the
21	* date we make the Software available; or offers the same or substantially
22	* similar functionality as the Software.
23	*
24	* NOTE: Parts of this file contain code from 'The eXist-db Authors'.
25	* The original license header is included below.
26	*
27	* =====================================================================
28	*
29	* eXist-db Open Source Native XML Database
30	* Copyright (C) 2001 The eXist-db Authors
31	*
32	* info@exist-db.org
33	* http://www.exist-db.org
34	*
35	* This library is free software; you can redistribute it and/or
36	* modify it under the terms of the GNU Lesser General Public
37	* License as published by the Free Software Foundation; either
38	* version 2.1 of the License, or (at your option) any later version.
39	*
40	* This library is distributed in the hope that it will be useful,
41	* but WITHOUT ANY WARRANTY; without even the implied warranty of
42	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
43	* Lesser General Public License for more details.
44	*
45	* You should have received a copy of the GNU Lesser General Public
46	* License along with this library; if not, write to the Free Software
47	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
48	*/
49	package org.exist.xquery.functions.fn;
50
51	import org.exist.dom.QName;
52	import org.exist.xquery.*;
53	import org.exist.xquery.value.*;
54
55	import javax.xml.datatype.DatatypeConstants;
56	import javax.xml.datatype.XMLGregorianCalendar;
57
58	import java.math.BigDecimal;
59	import java.math.BigInteger;
60
61	import java.util.Map;
62	import java.util.HashMap;
63	import java.util.Arrays;
64
65	import static org.exist.util.StringUtil.startsWith;
66
67	/**
68	* Parses a string containing the date and time in IETF format,
69	* returning the corresponding xs:dateTime value.
70	*
71	* @author Juri Leino (juri@existsolutions.com)
72	*/
73	public class FunParseIetfDate extends BasicFunction {
74
75	private static FunctionParameterSequenceType IETF_DATE =	1✔
76	new FunctionParameterSequenceType(	1✔
77	"value", Type.STRING, Cardinality.ZERO_OR_ONE, "The IETF-dateTime string");	1✔
78
79	private static FunctionReturnSequenceType RETURN =	1✔
80	new FunctionReturnSequenceType(	1✔
81	Type.DATE_TIME, Cardinality.ZERO_OR_ONE, "The parsed date");	1✔
82
83
84	public final static FunctionSignature FNS_PARSE_IETF_DATE = new FunctionSignature(	1✔
85	new QName("parse-ietf-date", Function.BUILTIN_FUNCTION_NS),	1✔
86	"Parses a string containing the date and time in IETF format,\n" +	1✔
87	"returning the corresponding xs:dateTime value.",
88	new SequenceType[]{IETF_DATE},	1✔
89	RETURN	1✔
90	);	1✔
91
92	public FunParseIetfDate(XQueryContext context, FunctionSignature signature) {
93	super(context, signature);	1✔
94	}	1✔
95
96	@Override
97	public Sequence eval(Sequence[] args, Sequence contextSequence) throws XPathException {
98	if (args[0].isEmpty()) {	1✔
99	return Sequence.EMPTY_SEQUENCE;	1✔
100	}
101	final String value = args[0].getStringValue();	1✔
102	final Parser p = new Parser(value.trim());	1✔
103
104	try {
105	return new DateTimeValue(this, p.parse());	1✔
106	} catch (final IllegalArgumentException i) {	1✔
107	throw new XPathException(this, ErrorCodes.FORG0010, "Invalid Date time " + value, i);	1✔
108	}
109	}
110
111	private class Parser {
112	private final char[] WS = {0x000A, 0x0009, 0x000D, 0x0020};	1✔
113	private final String WS_STR = new String(WS);	1✔
114
115	private final String[] dayNames = {	1✔
116	"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun",	1✔
117	"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"	1✔
118	};
119
120	private final String[] monthNames = {	1✔
121	"Jan", "Feb", "Mar", "Apr", "May", "Jun",	1✔
122	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"	1✔
123	};
124
125	private final String[] tzNames = {	1✔
126	"UT", "UTC", "GMT", "EST", "EDT", "CST", "CDT", "MST", "MDT", "PST", "PDT"	1✔
127	};
128
129	private final Map<String, Integer> TZ_MAP = initMap();	1✔
130	private final String value;
131	private final int vlen;
132	private int vidx;
133
134	private BigInteger year = null;	1✔
135	private int month = DatatypeConstants.FIELD_UNDEFINED;	1✔
136	private int day = DatatypeConstants.FIELD_UNDEFINED;	1✔
137
138	private int hour = DatatypeConstants.FIELD_UNDEFINED;	1✔
139	private int minute = DatatypeConstants.FIELD_UNDEFINED;	1✔
140	private int second = DatatypeConstants.FIELD_UNDEFINED;	1✔
141	private BigDecimal fractionalSecond = null;	1✔
142
143	private int timezone = DatatypeConstants.FIELD_UNDEFINED;	1✔
144
145	private Parser(String value) {	1✔
146	this.value = value;	1✔
147	this.vlen = value.length();	1✔
148	}	1✔
149
150	private Map<String, Integer> initMap() {
151	Map<String, Integer> result = new HashMap<>();	1✔
152	result.put("UT", 0);	1✔
153	result.put("UTC", 0);	1✔
154	result.put("GMT", 0);	1✔
155	result.put("EST", -5);	1✔
156	result.put("EDT", -4);	1✔
157	result.put("CST", -6);	1✔
158	result.put("CDT", -5);	1✔
159	result.put("MST", -7);	1✔
160	result.put("MDT", -6);	1✔
161	result.put("PST", -8);	1✔
162	result.put("PDT", -7);	1✔
163	return result;	1✔
164	}
165
166	/**
167	* <p>Parse a formatted <code>String</code> into an <code>XMLGregorianCalendar</code>.</p>
168	* <p>
169	* <p>If <code>String</code> is not formatted as a legal <code>IETF Date</code> value,
170	* an <code>IllegalArgumentException</code> is thrown.</p>
171	* <pre>
172	* input ::= (dayname ","? S)? ((datespec S time) \| asctime)
173	* datespec ::= daynum dsep monthname dsep year
174	* dsep ::= S \| (S? "-" S?)
175	* daynum ::= digit digit?
176	* year ::= digit digit (digit digit)?
177	* digit ::= [0-9]
178	* time ::= hours ":" minutes (":" seconds)? (S? timezone)?
179	* hours ::= digit digit?
180	* minutes ::= digit digit
181	* seconds ::= digit digit ("." digit+)?
182	* S ::= (x0A\|x09\|x0D\|x20)+
183	* </pre>
184	*
185	* @throws IllegalArgumentException If <code>String</code> is not formatted as a legal <code>IETF Date</code> value.
186	*/
187	public XMLGregorianCalendar parse() throws IllegalArgumentException {
188	dayName();	1✔
189	dateSpec();	1✔
190	if (vidx != vlen) {	1!
191	throw new IllegalArgumentException(value);	×
192	}
193	return TimeUtils	1✔
194	.getInstance()	1✔
195	.getFactory()	1✔
196	.newXMLGregorianCalendar(year, month, day, hour, minute, second, fractionalSecond, timezone);	1✔
197	}
198
199	private void dayName() {
200	if (startsWith(value, dayNames)) {	1✔
201	skipTo(WS_STR);	1✔
202	vidx++;	1✔
203	}
204	}	1✔
205
206	private void dateSpec() throws IllegalArgumentException {
207	if (isWS(peek())) {	1✔
208	skipWS();	1✔
209	}
210	if (startsWith(value.substring(vidx), monthNames)) {	1✔
211	asctime();	1✔
212	} else {	1✔
213	rfcDate();	1✔
214	}
215	}	1✔
216
217	private void rfcDate() throws IllegalArgumentException {
218	day();	1✔
219	dsep();	1✔
220	month();	1✔
221	dsep();	1✔
222	year();	1✔
223	skipWS();	1✔
224	time();	1✔
225	}	1✔
226
227	private void asctime() throws IllegalArgumentException {
228	month();	1✔
229	dsep();	1✔
230	day();	1✔
231	skipWS();	1✔
232	time();	1✔
233	skipWS();	1✔
234	year();	1✔
235	}	1✔
236
237	private void year() throws IllegalArgumentException {
238	final int vstart = vidx;	1✔
239
240	while (isDigit(peek())) {	1✔
241	vidx++;	1✔
242	}
243	final int digits = vidx - vstart;	1✔
244	String yearString;
245	if (digits == 2) {	1✔
246	yearString = "19" + value.substring(vstart, vidx);	1✔
247	} else if (digits == 4) {	1!
248	yearString = value.substring(vstart, vidx);	1✔
249	} else {	1✔
250	throw new IllegalArgumentException(value);	×
251	}
252
253	year = new BigInteger(yearString);	1✔
254	}	1✔
255
256	private void month() throws IllegalArgumentException {
257	final int vstart = vidx;	1✔
258	vidx += 3;	1✔
259	if (vidx >= vlen) {	1✔
260	throw new IllegalArgumentException(value);	1✔
261	}
262	final String monthName = value.substring(vstart, vidx);	1✔
263	final int idx = Arrays.asList(monthNames).indexOf(monthName);	1✔
264	if (idx < 0) {	1!
265	throw new IllegalArgumentException(value);	×
266	}
267	month = idx + 1;	1✔
268	}	1✔
269
270	private void day() throws IllegalArgumentException {
271	day = parseInt(1, 2);	1✔
272	}	1✔
273
274	private void time() throws IllegalArgumentException {
275	hours();	1✔
276	minutes();	1✔
277	seconds();	1✔
278	skipWS();	1✔
279	timezone();	1✔
280	}	1✔
281
282	private void hours() throws IllegalArgumentException {
283	hour = parseInt(2, 2);	1✔
284	}	1✔
285
286	private void minutes() throws IllegalArgumentException {
287	skip(':');	1✔
288	minute = parseInt(2, 2);	1✔
289	checkMinutes(minute);	1✔
290	}	1✔
291
292	private void seconds() throws IllegalArgumentException {
293	if (isWS(peek())) {	1!
294	second = 0;	×
295	return;	×
296	}
297	skip(':');	1✔
298	second = parseInt(2, 2);	1✔
299	fractionalSecond = parseBigDecimal();	1✔
300	}	1✔
301
302	private void timezone() throws IllegalArgumentException {
303	if (!startsWith(value.substring(vidx), tzNames)) {	1✔
304	tzoffset();	1✔
305	return;	1✔
306	}
307	parseTimezoneName();	1✔
308	}	1✔
309
310	private void parseTimezoneName() {
311	final int vstart = vidx;	1✔
312	while (isUpperCaseLetter(peek())) {	1✔
313	vidx++;	1✔
314	}
315	final String tzName = value.substring(vstart, vidx);	1✔
316	if (!TZ_MAP.containsKey(tzName)) {	1!
317	throw new IllegalArgumentException(value);	×
318	}
319	timezone = TZ_MAP.get(tzName) * 60;	1✔
320	}	1✔
321
322	private void tzoffset() throws IllegalArgumentException {
323	final char sign = peek();	1✔
324	if (!(sign == '+' \|\| sign == '-')) {	1!
325	throw new IllegalArgumentException(value);	×
326	}
327
328	vidx++;	1✔
329	final int h = parseInt(1, 2);	1✔
330
331	if (peek() == ':') {	1✔
332	skip(':');	1✔
333	}
334
335	int m = 0;	1✔
336	if (isDigit(peek())) {	1!
337	m = parseInt(2, 2);	1✔
338	}
339	checkMinutes(m);	1✔
340
341	final int offset = h * 60 + m;	1✔
342	final int factor = (sign == '+' ? 1 : -1);	1✔
343	timezone = offset * factor;	1✔
344
345	// cut off whitespace and optional timezone in parenthesis
346	if (isWS(peek()) \|\| peek() == '(') {	1!
347	vidx = vlen;	1✔
348	}
349	}	1✔
350
351	private void dsep() throws IllegalArgumentException {
352	if (isWS(peek())) {	1✔
353	skipWS();	1✔
354	}
355	if (peek() != '-') {	1✔
356	return;	1✔
357	}
358	skip('-');	1✔
359	if (isWS(peek())) {	1✔
360	skipWS();	1✔
361	}
362	}	1✔
363
364	private void skipWS() throws IllegalArgumentException {
365	if (!isWS(peek())) {	1!
366	throw new IllegalArgumentException(value);	×
367	}
368
369	while (isWS(peek())) {	1✔
370	vidx++;	1✔
371	}
372	}	1✔
373
374	private char peek() {
375	if (vidx == vlen) {	1✔
376	return (char) -1;	1✔
377	}
378	return value.charAt(vidx);	1✔
379	}
380
381	private char read() throws IllegalArgumentException {
382	if (vidx == vlen) {	1!
383	throw new IllegalArgumentException(value);	×
384	}
385	return value.charAt(vidx++);	1✔
386	}
387
388	private void skipTo(String sequence) throws IllegalArgumentException {
389	while (sequence.indexOf(peek()) < 0) {	1✔
390	read();	1✔
391	}
392	}	1✔
393
394	private void skip(char ch) throws IllegalArgumentException {
395	if (read() != ch) throw new IllegalArgumentException(value);	1✔
396	}	1✔
397
398	private int parseInt(int minDigits, int maxDigits) throws IllegalArgumentException {
399	final int vstart = vidx;	1✔
400	while (isDigit(peek()) && (vidx - vstart) < maxDigits) {	1✔
401	vidx++;	1✔
402	}
403	if ((vidx - vstart) < minDigits) {	1✔
404	// we are expecting more digits
405	throw new IllegalArgumentException(value);	1✔
406	}
407
408	return Integer.parseInt(value.substring(vstart, vidx));	1✔
409	}
410
411	private BigDecimal parseBigDecimal() throws IllegalArgumentException {
412	final int vstart = vidx;	1✔
413
414	if (peek() == '.') {	1!
415	vidx++;	×
416	} else {	×
417	return new BigDecimal("0");	1✔
418	}
419	while (isDigit(peek())) {	×
420	vidx++;	×
421	}
422	return new BigDecimal(value.substring(vstart, vidx));	×
423	}
424
425	private void checkMinutes(int m) {
426	if (m >= 60 \|\| m < 0) {	1!
427	throw new IllegalArgumentException(value);	×
428	}
429	}	1✔
430
431	private boolean isWS(char c) {
432	return (WS_STR.indexOf(c) >= 0);	1✔
433	}
434
435	private boolean isDigit(char ch) {
436	return '0' <= ch && ch <= '9';	1✔
437	}
438
439	private boolean isUpperCaseLetter(char ch) {
440	return 'A' <= ch && ch <= 'Z';	1✔
441	}
442	}
443	}

evolvedbinary / elemental / 982

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous