| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package freemarker.template.utility; |
| |
| import java.text.ParseException; |
| import java.util.Calendar; |
| import java.util.Date; |
| import java.util.GregorianCalendar; |
| import java.util.Locale; |
| import java.util.TimeZone; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| /** |
| * Date and time related utilities. |
| */ |
| public class DateUtil { |
| |
| /** |
| * Show hours (24h); always 2 digits, like {@code 00}, {@code 05}, etc. |
| */ |
| public static final int ACCURACY_HOURS = 4; |
| |
| /** |
| * Show hours and minutes (even if minutes is 00). |
| */ |
| public static final int ACCURACY_MINUTES = 5; |
| |
| /** |
| * Show hours, minutes and seconds (even if seconds is 00). |
| */ |
| public static final int ACCURACY_SECONDS = 6; |
| |
| /** |
| * Show hours, minutes and seconds and up to 3 fraction second digits, without trailing 0-s in the fraction part. |
| */ |
| public static final int ACCURACY_MILLISECONDS = 7; |
| |
| /** |
| * Show hours, minutes and seconds and exactly 3 fraction second digits (even if it's 000) |
| */ |
| public static final int ACCURACY_MILLISECONDS_FORCED = 8; |
| |
| public static final TimeZone UTC = TimeZone.getTimeZone("UTC"); |
| |
| private static final String REGEX_XS_TIME_ZONE |
| = "Z|(?:[-+][0-9]{2}:[0-9]{2})"; |
| private static final String REGEX_ISO8601_BASIC_TIME_ZONE |
| = "Z|(?:[-+][0-9]{2}(?:[0-9]{2})?)"; |
| private static final String REGEX_ISO8601_EXTENDED_TIME_ZONE |
| = "Z|(?:[-+][0-9]{2}(?::[0-9]{2})?)"; |
| |
| private static final String REGEX_XS_OPTIONAL_TIME_ZONE |
| = "(" + REGEX_XS_TIME_ZONE + ")?"; |
| private static final String REGEX_ISO8601_BASIC_OPTIONAL_TIME_ZONE |
| = "(" + REGEX_ISO8601_BASIC_TIME_ZONE + ")?"; |
| private static final String REGEX_ISO8601_EXTENDED_OPTIONAL_TIME_ZONE |
| = "(" + REGEX_ISO8601_EXTENDED_TIME_ZONE + ")?"; |
| |
| private static final String REGEX_XS_DATE_BASE |
| = "(-?[0-9]+)-([0-9]{2})-([0-9]{2})"; |
| private static final String REGEX_ISO8601_BASIC_DATE_BASE |
| = "(-?[0-9]{4,}?)([0-9]{2})([0-9]{2})"; |
| private static final String REGEX_ISO8601_EXTENDED_DATE_BASE |
| = "(-?[0-9]{4,})-([0-9]{2})-([0-9]{2})"; |
| |
| private static final String REGEX_XS_TIME_BASE |
| = "([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\\.([0-9]+))?"; |
| private static final String REGEX_ISO8601_BASIC_TIME_BASE |
| = "([0-9]{2})(?:([0-9]{2})(?:([0-9]{2})(?:[\\.,]([0-9]+))?)?)?"; |
| private static final String REGEX_ISO8601_EXTENDED_TIME_BASE |
| = "([0-9]{2})(?::([0-9]{2})(?::([0-9]{2})(?:[\\.,]([0-9]+))?)?)?"; |
| |
| private static final Pattern PATTERN_XS_DATE = Pattern.compile( |
| REGEX_XS_DATE_BASE + REGEX_XS_OPTIONAL_TIME_ZONE); |
| private static final Pattern PATTERN_ISO8601_BASIC_DATE = Pattern.compile( |
| REGEX_ISO8601_BASIC_DATE_BASE); // No time zone allowed here |
| private static final Pattern PATTERN_ISO8601_EXTENDED_DATE = Pattern.compile( |
| REGEX_ISO8601_EXTENDED_DATE_BASE); // No time zone allowed here |
| |
| private static final Pattern PATTERN_XS_TIME = Pattern.compile( |
| REGEX_XS_TIME_BASE + REGEX_XS_OPTIONAL_TIME_ZONE); |
| private static final Pattern PATTERN_ISO8601_BASIC_TIME = Pattern.compile( |
| REGEX_ISO8601_BASIC_TIME_BASE + REGEX_ISO8601_BASIC_OPTIONAL_TIME_ZONE); |
| private static final Pattern PATTERN_ISO8601_EXTENDED_TIME = Pattern.compile( |
| REGEX_ISO8601_EXTENDED_TIME_BASE + REGEX_ISO8601_EXTENDED_OPTIONAL_TIME_ZONE); |
| |
| private static final Pattern PATTERN_XS_DATE_TIME = Pattern.compile( |
| REGEX_XS_DATE_BASE |
| + "T" + REGEX_XS_TIME_BASE |
| + REGEX_XS_OPTIONAL_TIME_ZONE); |
| private static final Pattern PATTERN_ISO8601_BASIC_DATE_TIME = Pattern.compile( |
| REGEX_ISO8601_BASIC_DATE_BASE |
| + "T" + REGEX_ISO8601_BASIC_TIME_BASE |
| + REGEX_ISO8601_BASIC_OPTIONAL_TIME_ZONE); |
| private static final Pattern PATTERN_ISO8601_EXTENDED_DATE_TIME = Pattern.compile( |
| REGEX_ISO8601_EXTENDED_DATE_BASE |
| + "T" + REGEX_ISO8601_EXTENDED_TIME_BASE |
| + REGEX_ISO8601_EXTENDED_OPTIONAL_TIME_ZONE); |
| |
| private static final Pattern PATTERN_XS_TIME_ZONE = Pattern.compile( |
| REGEX_XS_TIME_ZONE); |
| |
| private static final String MSG_YEAR_0_NOT_ALLOWED |
| = "Year 0 is not allowed in XML schema dates. BC 1 is -1, AD 1 is 1."; |
| |
| private DateUtil() { |
| // can't be instantiated |
| } |
| |
| /** |
| * Returns the time zone object for the name (or ID). This differs from |
| * {@link TimeZone#getTimeZone(String)} in that the latest returns GMT |
| * if it doesn't recognize the name, while this throws an |
| * {@link UnrecognizedTimeZoneException}. |
| * |
| * @throws UnrecognizedTimeZoneException If the time zone name wasn't understood |
| */ |
| public static TimeZone getTimeZone(String name) |
| throws UnrecognizedTimeZoneException { |
| if (isGMTish(name)) { |
| if (name.equalsIgnoreCase("UTC")) { |
| return UTC; |
| } |
| return TimeZone.getTimeZone(name); |
| } |
| TimeZone tz = TimeZone.getTimeZone(name); |
| if (isGMTish(tz.getID())) { |
| throw new UnrecognizedTimeZoneException(name); |
| } |
| return tz; |
| } |
| |
| /** |
| * Tells if a offset or time zone is GMT. GMT is a fuzzy term, it used to |
| * referred both to UTC and UT1. |
| */ |
| private static boolean isGMTish(String name) { |
| if (name.length() < 3) { |
| return false; |
| } |
| char c1 = name.charAt(0); |
| char c2 = name.charAt(1); |
| char c3 = name.charAt(2); |
| if ( |
| !( |
| (c1 == 'G' || c1 == 'g') |
| && (c2 == 'M' || c2 == 'm') |
| && (c3 == 'T' || c3 == 't') |
| ) |
| && |
| !( |
| (c1 == 'U' || c1 == 'u') |
| && (c2 == 'T' || c2 == 't') |
| && (c3 == 'C' || c3 == 'c') |
| ) |
| && |
| !( |
| (c1 == 'U' || c1 == 'u') |
| && (c2 == 'T' || c2 == 't') |
| && (c3 == '1') |
| ) |
| ) { |
| return false; |
| } |
| |
| if (name.length() == 3) { |
| return true; |
| } |
| |
| String offset = name.substring(3); |
| if (offset.startsWith("+")) { |
| return offset.equals("+0") || offset.equals("+00") |
| || offset.equals("+00:00"); |
| } else { |
| return offset.equals("-0") || offset.equals("-00") |
| || offset.equals("-00:00"); |
| } |
| } |
| |
| /** |
| * Format a date, time or dateTime with one of the ISO 8601 extended |
| * formats that is also compatible with the XML Schema format (as far as you |
| * don't have dates in the BC era). Examples of possible outputs: |
| * {@code "2005-11-27T15:30:00+02:00"}, {@code "2005-11-27"}, |
| * {@code "15:30:00Z"}. Note the {@code ":00"} in the time zone offset; |
| * this is not required by ISO 8601, but included for compatibility with |
| * the XML Schema format. Regarding the B.C. issue, those dates will be |
| * one year off when read back according the XML Schema format, because of a |
| * mismatch between that format and ISO 8601:2000 Second Edition. |
| * |
| * <p>This method is thread-safe. |
| * |
| * @param date the date to convert to ISO 8601 string |
| * @param datePart whether the date part (year, month, day) will be included |
| * or not |
| * @param timePart whether the time part (hours, minutes, seconds, |
| * milliseconds) will be included or not |
| * @param offsetPart whether the time zone offset part will be included or |
| * not. This will be shown as an offset to UTC (examples: |
| * {@code "+01"}, {@code "-02"}, {@code "+04:30"}) or as {@code "Z"} |
| * for UTC (and for UT1 and for GMT+00, since the Java platform |
| * doesn't really care about the difference). |
| * Note that this can't be {@code true} when {@code timePart} is |
| * {@code false}, because ISO 8601 (2004) doesn't mention such |
| * patterns. |
| * @param accuracy tells which parts of the date/time to drop. The |
| * {@code datePart} and {@code timePart} parameters are stronger than |
| * this. Note that when {@link #ACCURACY_MILLISECONDS} is specified, |
| * the milliseconds part will be displayed as fraction seconds |
| * (like {@code "15:30.00.25"}) with the minimum number of |
| * digits needed to show the milliseconds without precision lose. |
| * Thus, if the milliseconds happen to be exactly 0, no fraction |
| * seconds will be shown at all. |
| * @param timeZone the time zone in which the date/time will be shown. (You |
| * may find {@link DateUtil#UTC} handy here.) Note |
| * that although date-only formats has no time zone offset part, |
| * the result still depends on the time zone, as days start and end |
| * at different points on the time line in different zones. |
| * @param calendarFactory the factory that will create the calendar used |
| * internally for calculations. The point of this parameter is that |
| * creating a new calendar is relatively expensive, so it's desirable |
| * to reuse calendars and only set their time and zone. (This was |
| * tested on Sun JDK 1.6 x86 Win, where it gave 2x-3x speedup.) |
| */ |
| public static String dateToISO8601String( |
| Date date, |
| boolean datePart, boolean timePart, boolean offsetPart, |
| int accuracy, |
| TimeZone timeZone, |
| DateToISO8601CalendarFactory calendarFactory) { |
| return dateToString(date, datePart, timePart, offsetPart, accuracy, timeZone, false, calendarFactory); |
| } |
| |
| /** |
| * Same as {@link #dateToISO8601String}, but gives XML Schema compliant format. |
| */ |
| public static String dateToXSString( |
| Date date, |
| boolean datePart, boolean timePart, boolean offsetPart, |
| int accuracy, |
| TimeZone timeZone, |
| DateToISO8601CalendarFactory calendarFactory) { |
| return dateToString(date, datePart, timePart, offsetPart, accuracy, timeZone, true, calendarFactory); |
| } |
| |
| private static String dateToString( |
| Date date, |
| boolean datePart, boolean timePart, boolean offsetPart, |
| int accuracy, |
| TimeZone timeZone, boolean xsMode, |
| DateToISO8601CalendarFactory calendarFactory) { |
| if (!xsMode && !timePart && offsetPart) { |
| throw new IllegalArgumentException( |
| "ISO 8601:2004 doesn't specify any formats where the " |
| + "offset is shown but the time isn't."); |
| } |
| |
| if (timeZone == null) { |
| timeZone = UTC; |
| } |
| |
| GregorianCalendar cal = calendarFactory.get(timeZone, date); |
| |
| int maxLength; |
| if (!timePart) { |
| maxLength = 10 + (xsMode ? 6 : 0); // YYYY-MM-DD+00:00 |
| } else { |
| if (!datePart) { |
| maxLength = 12 + 6; // HH:MM:SS.mmm+00:00 |
| } else { |
| maxLength = 10 + 1 + 12 + 6; |
| } |
| } |
| char[] res = new char[maxLength]; |
| int dstIdx = 0; |
| |
| if (datePart) { |
| int x = cal.get(Calendar.YEAR); |
| if (x > 0 && cal.get(Calendar.ERA) == GregorianCalendar.BC) { |
| x = -x + (xsMode ? 0 : 1); |
| } |
| if (x >= 0 && x < 9999) { |
| res[dstIdx++] = (char) ('0' + x / 1000); |
| res[dstIdx++] = (char) ('0' + x % 1000 / 100); |
| res[dstIdx++] = (char) ('0' + x % 100 / 10); |
| res[dstIdx++] = (char) ('0' + x % 10); |
| } else { |
| String yearString = String.valueOf(x); |
| |
| // Re-allocate buffer: |
| maxLength = maxLength - 4 + yearString.length(); |
| res = new char[maxLength]; |
| |
| for (int i = 0; i < yearString.length(); i++) { |
| res[dstIdx++] = yearString.charAt(i); |
| } |
| } |
| |
| res[dstIdx++] = '-'; |
| |
| x = cal.get(Calendar.MONTH) + 1; |
| dstIdx = append00(res, dstIdx, x); |
| |
| res[dstIdx++] = '-'; |
| |
| x = cal.get(Calendar.DAY_OF_MONTH); |
| dstIdx = append00(res, dstIdx, x); |
| |
| if (timePart) { |
| res[dstIdx++] = 'T'; |
| } |
| } |
| |
| if (timePart) { |
| int x = cal.get(Calendar.HOUR_OF_DAY); |
| dstIdx = append00(res, dstIdx, x); |
| |
| if (accuracy >= ACCURACY_MINUTES) { |
| res[dstIdx++] = ':'; |
| |
| x = cal.get(Calendar.MINUTE); |
| dstIdx = append00(res, dstIdx, x); |
| |
| if (accuracy >= ACCURACY_SECONDS) { |
| res[dstIdx++] = ':'; |
| |
| x = cal.get(Calendar.SECOND); |
| dstIdx = append00(res, dstIdx, x); |
| |
| if (accuracy >= ACCURACY_MILLISECONDS) { |
| x = cal.get(Calendar.MILLISECOND); |
| int forcedDigits = accuracy == ACCURACY_MILLISECONDS_FORCED ? 3 : 0; |
| if (x != 0 || forcedDigits != 0) { |
| if (x > 999) { |
| // Shouldn't ever happen... |
| throw new RuntimeException( |
| "Calendar.MILLISECOND > 999"); |
| } |
| res[dstIdx++] = '.'; |
| do { |
| res[dstIdx++] = (char) ('0' + (x / 100)); |
| forcedDigits--; |
| x = x % 100 * 10; |
| } while (x != 0 || forcedDigits > 0); |
| } |
| } |
| } |
| } |
| } |
| |
| if (offsetPart) { |
| if (timeZone == UTC) { |
| res[dstIdx++] = 'Z'; |
| } else { |
| int dt = timeZone.getOffset(date.getTime()); |
| boolean positive; |
| if (dt < 0) { |
| positive = false; |
| dt = -dt; |
| } else { |
| positive = true; |
| } |
| |
| dt /= 1000; |
| int offS = dt % 60; |
| dt /= 60; |
| int offM = dt % 60; |
| dt /= 60; |
| int offH = dt; |
| |
| if (offS == 0 && offM == 0 && offH == 0) { |
| res[dstIdx++] = 'Z'; |
| } else { |
| res[dstIdx++] = positive ? '+' : '-'; |
| dstIdx = append00(res, dstIdx, offH); |
| res[dstIdx++] = ':'; |
| dstIdx = append00(res, dstIdx, offM); |
| if (offS != 0) { |
| res[dstIdx++] = ':'; |
| dstIdx = append00(res, dstIdx, offS); |
| } |
| } |
| } |
| } |
| |
| return new String(res, 0, dstIdx); |
| } |
| |
| /** |
| * Appends a number between 0 and 99 padded to 2 digits. |
| */ |
| private static int append00(char[] res, int dstIdx, int x) { |
| res[dstIdx++] = (char) ('0' + x / 10); |
| res[dstIdx++] = (char) ('0' + x % 10); |
| return dstIdx; |
| } |
| |
| /** |
| * Parses an W3C XML Schema date string (not time or date-time). |
| * Unlike in ISO 8601:2000 Second Edition, year -1 means B.C 1, and year 0 is invalid. |
| * |
| * @param dateStr the string to parse. |
| * @param defaultTimeZone used if the date doesn't specify the |
| * time zone offset explicitly. Can't be {@code null}. |
| * @param calToDateConverter Used internally to calculate the result from the calendar field values. |
| * If you don't have a such object around, you can just use |
| * {@code new }{@link TrivialCalendarFieldsToDateConverter}{@code ()}. |
| * |
| * @throws DateParseException if the date is malformed, or if the time |
| * zone offset is unspecified and the {@code defaultTimeZone} is |
| * {@code null}. |
| */ |
| public static Date parseXSDate( |
| String dateStr, TimeZone defaultTimeZone, |
| CalendarFieldsToDateConverter calToDateConverter) |
| throws DateParseException { |
| Matcher m = PATTERN_XS_DATE.matcher(dateStr); |
| if (!m.matches()) { |
| throw new DateParseException("The value didn't match the expected pattern: " + PATTERN_XS_DATE); |
| } |
| return parseDate_parseMatcher( |
| m, defaultTimeZone, true, calToDateConverter); |
| } |
| |
| /** |
| * Same as {@link #parseXSDate(String, TimeZone, CalendarFieldsToDateConverter)}, but for ISO 8601 dates. |
| */ |
| public static Date parseISO8601Date( |
| String dateStr, TimeZone defaultTimeZone, |
| CalendarFieldsToDateConverter calToDateConverter) |
| throws DateParseException { |
| Matcher m = PATTERN_ISO8601_EXTENDED_DATE.matcher(dateStr); |
| if (!m.matches()) { |
| m = PATTERN_ISO8601_BASIC_DATE.matcher(dateStr); |
| if (!m.matches()) { |
| throw new DateParseException("The value didn't match the expected pattern: " |
| + PATTERN_ISO8601_EXTENDED_DATE + " or " |
| + PATTERN_ISO8601_BASIC_DATE); |
| } |
| } |
| return parseDate_parseMatcher( |
| m, defaultTimeZone, false, calToDateConverter); |
| } |
| |
| private static Date parseDate_parseMatcher( |
| Matcher m, TimeZone defaultTZ, |
| boolean xsMode, |
| CalendarFieldsToDateConverter calToDateConverter) |
| throws DateParseException { |
| NullArgumentException.check("defaultTZ", defaultTZ); |
| try { |
| int year = groupToInt(m.group(1), "year", Integer.MIN_VALUE, Integer.MAX_VALUE); |
| |
| int era; |
| // Starting from ISO 8601:2000 Second Edition, 0001 is AD 1, 0000 is BC 1, -0001 is BC 2. |
| // However, according to http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/, XML schemas are based |
| // on the earlier version where 0000 didn't exist, and year -1 is BC 1. |
| if (year <= 0) { |
| era = GregorianCalendar.BC; |
| year = -year + (xsMode ? 0 : 1); |
| if (year == 0) { |
| throw new DateParseException(MSG_YEAR_0_NOT_ALLOWED); |
| } |
| } else { |
| era = GregorianCalendar.AD; |
| } |
| |
| int month = groupToInt(m.group(2), "month", 1, 12) - 1; |
| int day = groupToInt(m.group(3), "day-of-month", 1, 31); |
| |
| TimeZone tz = xsMode ? parseMatchingTimeZone(m.group(4), defaultTZ) : defaultTZ; |
| |
| return calToDateConverter.calculate(era, year, month, day, 0, 0, 0, 0, false, tz); |
| } catch (IllegalArgumentException e) { |
| // Calendar methods used to throw this for illegal dates. |
| throw new DateParseException( |
| "Date calculation faliure. " |
| + "Probably the date is formally correct, but refers " |
| + "to an unexistent date (like February 30)."); |
| } |
| } |
| |
| /** |
| * Parses an W3C XML Schema time string (not date or date-time). |
| * If the time string doesn't specify the time zone offset explicitly, |
| * the value of the {@code defaultTZ} paramter will be used. |
| */ |
| public static Date parseXSTime( |
| String timeStr, TimeZone defaultTZ, CalendarFieldsToDateConverter calToDateConverter) |
| throws DateParseException { |
| Matcher m = PATTERN_XS_TIME.matcher(timeStr); |
| if (!m.matches()) { |
| throw new DateParseException("The value didn't match the expected pattern: " + PATTERN_XS_TIME); |
| } |
| return parseTime_parseMatcher(m, defaultTZ, calToDateConverter); |
| } |
| |
| /** |
| * Same as {@link #parseXSTime(String, TimeZone, CalendarFieldsToDateConverter)} but for ISO 8601 times. |
| */ |
| public static Date parseISO8601Time( |
| String timeStr, TimeZone defaultTZ, CalendarFieldsToDateConverter calToDateConverter) |
| throws DateParseException { |
| Matcher m = PATTERN_ISO8601_EXTENDED_TIME.matcher(timeStr); |
| if (!m.matches()) { |
| m = PATTERN_ISO8601_BASIC_TIME.matcher(timeStr); |
| if (!m.matches()) { |
| throw new DateParseException("The value didn't match the expected pattern: " |
| + PATTERN_ISO8601_EXTENDED_TIME + " or " |
| + PATTERN_ISO8601_BASIC_TIME); |
| } |
| } |
| return parseTime_parseMatcher(m, defaultTZ, calToDateConverter); |
| } |
| |
| private static Date parseTime_parseMatcher( |
| Matcher m, TimeZone defaultTZ, |
| CalendarFieldsToDateConverter calToDateConverter) |
| throws DateParseException { |
| NullArgumentException.check("defaultTZ", defaultTZ); |
| try { |
| // ISO 8601 allows both 00:00 and 24:00, |
| // but Calendar.set(...) doesn't if the Calendar is not lenient. |
| int hours = groupToInt(m.group(1), "hour-of-day", 0, 24); |
| boolean hourWas24; |
| if (hours == 24) { |
| hours = 0; |
| hourWas24 = true; |
| // And a day will be added later... |
| } else { |
| hourWas24 = false; |
| } |
| |
| final String minutesStr = m.group(2); |
| int minutes = minutesStr != null ? groupToInt(minutesStr, "minute", 0, 59) : 0; |
| |
| final String secsStr = m.group(3); |
| // Allow 60 because of leap seconds |
| int secs = secsStr != null ? groupToInt(secsStr, "second", 0, 60) : 0; |
| |
| int millisecs = groupToMillisecond(m.group(4)); |
| |
| // As a time is just the distance from the beginning of the day, |
| // the time-zone offest should be 0 usually. |
| TimeZone tz = parseMatchingTimeZone(m.group(5), defaultTZ); |
| |
| // Continue handling the 24:00 special case |
| int day; |
| if (hourWas24) { |
| if (minutes == 0 && secs == 0 && millisecs == 0) { |
| day = 2; |
| } else { |
| throw new DateParseException( |
| "Hour 24 is only allowed in the case of " |
| + "midnight."); |
| } |
| } else { |
| day = 1; |
| } |
| |
| return calToDateConverter.calculate( |
| GregorianCalendar.AD, 1970, 0, day, hours, minutes, secs, millisecs, false, tz); |
| } catch (IllegalArgumentException e) { |
| // Calendar methods used to throw this for illegal dates. |
| throw new DateParseException( |
| "Unexpected time calculation faliure."); |
| } |
| } |
| |
| /** |
| * Parses an W3C XML Schema date-time string (not date or time). |
| * Unlike in ISO 8601:2000 Second Edition, year -1 means B.C 1, and year 0 is invalid. |
| * |
| * @param dateTimeStr the string to parse. |
| * @param defaultTZ used if the dateTime doesn't specify the |
| * time zone offset explicitly. Can't be {@code null}. |
| * |
| * @throws DateParseException if the dateTime is malformed. |
| */ |
| public static Date parseXSDateTime( |
| String dateTimeStr, TimeZone defaultTZ, CalendarFieldsToDateConverter calToDateConverter) |
| throws DateParseException { |
| Matcher m = PATTERN_XS_DATE_TIME.matcher(dateTimeStr); |
| if (!m.matches()) { |
| throw new DateParseException( |
| "The value didn't match the expected pattern: " + PATTERN_XS_DATE_TIME); |
| } |
| return parseDateTime_parseMatcher( |
| m, defaultTZ, true, calToDateConverter); |
| } |
| |
| /** |
| * Same as {@link #parseXSDateTime(String, TimeZone, CalendarFieldsToDateConverter)} but for ISO 8601 format. |
| */ |
| public static Date parseISO8601DateTime( |
| String dateTimeStr, TimeZone defaultTZ, CalendarFieldsToDateConverter calToDateConverter) |
| throws DateParseException { |
| Matcher m = PATTERN_ISO8601_EXTENDED_DATE_TIME.matcher(dateTimeStr); |
| if (!m.matches()) { |
| m = PATTERN_ISO8601_BASIC_DATE_TIME.matcher(dateTimeStr); |
| if (!m.matches()) { |
| throw new DateParseException("The value (" + dateTimeStr + ") didn't match the expected pattern: " |
| + PATTERN_ISO8601_EXTENDED_DATE_TIME + " or " |
| + PATTERN_ISO8601_BASIC_DATE_TIME); |
| } |
| } |
| return parseDateTime_parseMatcher( |
| m, defaultTZ, false, calToDateConverter); |
| } |
| |
| private static Date parseDateTime_parseMatcher( |
| Matcher m, TimeZone defaultTZ, |
| boolean xsMode, |
| CalendarFieldsToDateConverter calToDateConverter) |
| throws DateParseException { |
| NullArgumentException.check("defaultTZ", defaultTZ); |
| try { |
| int year = groupToInt(m.group(1), "year", Integer.MIN_VALUE, Integer.MAX_VALUE); |
| |
| int era; |
| // Starting from ISO 8601:2000 Second Edition, 0001 is AD 1, 0000 is BC 1, -0001 is BC 2. |
| // However, according to http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/, XML schemas are based |
| // on the earlier version where 0000 didn't exist, and year -1 is BC 1. |
| if (year <= 0) { |
| era = GregorianCalendar.BC; |
| year = -year + (xsMode ? 0 : 1); |
| if (year == 0) { |
| throw new DateParseException(MSG_YEAR_0_NOT_ALLOWED); |
| } |
| } else { |
| era = GregorianCalendar.AD; |
| } |
| |
| int month = groupToInt(m.group(2), "month", 1, 12) - 1; |
| int day = groupToInt(m.group(3), "day-of-month", 1, 31); |
| |
| // ISO 8601 allows both 00:00 and 24:00, |
| // but cal.set(...) doesn't if the Calendar is not lenient. |
| int hours = groupToInt(m.group(4), "hour-of-day", 0, 24); |
| boolean hourWas24; |
| if (hours == 24) { |
| hours = 0; |
| hourWas24 = true; |
| // And a day will be added later... |
| } else { |
| hourWas24 = false; |
| } |
| |
| final String minutesStr = m.group(5); |
| int minutes = minutesStr != null ? groupToInt(minutesStr, "minute", 0, 59) : 0; |
| |
| final String secsStr = m.group(6); |
| // Allow 60 because of leap seconds |
| int secs = secsStr != null ? groupToInt(secsStr, "second", 0, 60) : 0; |
| |
| int millisecs = groupToMillisecond(m.group(7)); |
| |
| // As a time is just the distance from the beginning of the day, |
| // the time-zone offest should be 0 usually. |
| TimeZone tz = parseMatchingTimeZone(m.group(8), defaultTZ); |
| |
| // Continue handling the 24:00 specail case |
| if (hourWas24) { |
| if (minutes != 0 || secs != 0 || millisecs != 0) { |
| throw new DateParseException( |
| "Hour 24 is only allowed in the case of " |
| + "midnight."); |
| } |
| } |
| |
| return calToDateConverter.calculate( |
| era, year, month, day, hours, minutes, secs, millisecs, hourWas24, tz); |
| } catch (IllegalArgumentException e) { |
| // Calendar methods used to throw this for illegal dates. |
| throw new DateParseException( |
| "Date-time calculation faliure. " |
| + "Probably the date-time is formally correct, but " |
| + "refers to an unexistent date-time " |
| + "(like February 30)."); |
| } |
| } |
| |
| /** |
| * Parses the time zone part from a W3C XML Schema date/time/dateTime. |
| * @throws DateParseException if the zone is malformed. |
| */ |
| public static TimeZone parseXSTimeZone(String timeZoneStr) |
| throws DateParseException { |
| Matcher m = PATTERN_XS_TIME_ZONE.matcher(timeZoneStr); |
| if (!m.matches()) { |
| throw new DateParseException( |
| "The time zone offset didn't match the expected pattern: " + PATTERN_XS_TIME_ZONE); |
| } |
| return parseMatchingTimeZone(timeZoneStr, null); |
| } |
| |
| private static int groupToInt(String g, String gName, |
| int min, int max) |
| throws DateParseException { |
| if (g == null) { |
| throw new DateParseException("The " + gName + " part " |
| + "is missing."); |
| } |
| |
| int start; |
| |
| // Remove minus sign, so we can remove the 0-s later: |
| boolean negative; |
| if (g.startsWith("-")) { |
| negative = true; |
| start = 1; |
| } else { |
| negative = false; |
| start = 0; |
| } |
| |
| // Remove leading 0-s: |
| while (start < g.length() - 1 && g.charAt(start) == '0') { |
| start++; |
| } |
| if (start != 0) { |
| g = g.substring(start); |
| } |
| |
| try { |
| int r = Integer.parseInt(g); |
| if (negative) { |
| r = -r; |
| } |
| if (r < min) { |
| throw new DateParseException("The " + gName + " part " |
| + "must be at least " + min + "."); |
| } |
| if (r > max) { |
| throw new DateParseException("The " + gName + " part " |
| + "can't be more than " + max + "."); |
| } |
| return r; |
| } catch (NumberFormatException e) { |
| throw new DateParseException("The " + gName + " part " |
| + "is a malformed integer."); |
| } |
| } |
| |
| private static TimeZone parseMatchingTimeZone( |
| String s, TimeZone defaultZone) |
| throws DateParseException { |
| if (s == null) { |
| return defaultZone; |
| } |
| if (s.equals("Z")) { |
| return DateUtil.UTC; |
| } |
| |
| StringBuilder sb = new StringBuilder(9); |
| sb.append("GMT"); |
| sb.append(s.charAt(0)); |
| |
| String h = s.substring(1, 3); |
| groupToInt(h, "offset-hours", 0, 23); |
| sb.append(h); |
| |
| String m; |
| int ln = s.length(); |
| if (ln > 3) { |
| int startIdx = s.charAt(3) == ':' ? 4 : 3; |
| m = s.substring(startIdx, startIdx + 2); |
| groupToInt(m, "offset-minutes", 0, 59); |
| sb.append(':'); |
| sb.append(m); |
| } |
| |
| return TimeZone.getTimeZone(sb.toString()); |
| } |
| |
| private static int groupToMillisecond(String g) |
| throws DateParseException { |
| if (g == null) { |
| return 0; |
| } |
| |
| if (g.length() > 3) { |
| g = g.substring(0, 3); |
| } |
| int i = groupToInt(g, "partial-seconds", 0, Integer.MAX_VALUE); |
| return g.length() == 1 ? i * 100 : (g.length() == 2 ? i * 10 : i); |
| } |
| |
| /** |
| * Used internally by {@link DateUtil}; don't use its implementations for |
| * anything else. |
| */ |
| public interface DateToISO8601CalendarFactory { |
| |
| /** |
| * Returns a {@link GregorianCalendar} with the desired time zone and |
| * time and US locale. The returned calendar is used as read-only. |
| * It must be guaranteed that within a thread the instance returned last time |
| * is not in use anymore when this method is called again. |
| */ |
| GregorianCalendar get(TimeZone tz, Date date); |
| |
| } |
| |
| /** |
| * Used internally by {@link DateUtil}; don't use its implementations for anything else. |
| */ |
| public interface CalendarFieldsToDateConverter { |
| |
| /** |
| * Calculates the {@link Date} from the specified calendar fields. |
| */ |
| Date calculate(int era, int year, int month, int day, int hours, int minutes, int secs, int millisecs, |
| boolean addOneDay, |
| TimeZone tz); |
| |
| } |
| |
| /** |
| * Non-thread-safe factory that hard-references a calendar internally. |
| */ |
| public static final class TrivialDateToISO8601CalendarFactory |
| implements DateToISO8601CalendarFactory { |
| |
| private GregorianCalendar calendar; |
| private TimeZone lastlySetTimeZone; |
| |
| public GregorianCalendar get(TimeZone tz, Date date) { |
| if (calendar == null) { |
| calendar = new GregorianCalendar(tz, Locale.US); |
| calendar.setGregorianChange(new Date(Long.MIN_VALUE)); // never use Julian calendar |
| } else { |
| // At least on Java 6, calendar.getTimeZone is slow due to a bug, so we need lastlySetTimeZone. |
| if (lastlySetTimeZone != tz) { // Deliberately `!=` instead of `!<...>.equals()` |
| calendar.setTimeZone(tz); |
| lastlySetTimeZone = tz; |
| } |
| } |
| calendar.setTime(date); |
| return calendar; |
| } |
| |
| } |
| |
| /** |
| * Non-thread-safe implementation that hard-references a calendar internally. |
| */ |
| public static final class TrivialCalendarFieldsToDateConverter |
| implements CalendarFieldsToDateConverter { |
| |
| private GregorianCalendar calendar; |
| private TimeZone lastlySetTimeZone; |
| |
| public Date calculate(int era, int year, int month, int day, int hours, int minutes, int secs, int millisecs, |
| boolean addOneDay, TimeZone tz) { |
| if (calendar == null) { |
| calendar = new GregorianCalendar(tz, Locale.US); |
| calendar.setLenient(false); |
| calendar.setGregorianChange(new Date(Long.MIN_VALUE)); // never use Julian calendar |
| } else { |
| // At least on Java 6, calendar.getTimeZone is slow due to a bug, so we need lastlySetTimeZone. |
| if (lastlySetTimeZone != tz) { // Deliberately `!=` instead of `!<...>.equals()` |
| calendar.setTimeZone(tz); |
| lastlySetTimeZone = tz; |
| } |
| } |
| |
| calendar.set(Calendar.ERA, era); |
| calendar.set(Calendar.YEAR, year); |
| calendar.set(Calendar.MONTH, month); |
| calendar.set(Calendar.DAY_OF_MONTH, day); |
| calendar.set(Calendar.HOUR_OF_DAY, hours); |
| calendar.set(Calendar.MINUTE, minutes); |
| calendar.set(Calendar.SECOND, secs); |
| calendar.set(Calendar.MILLISECOND, millisecs); |
| if (addOneDay) { |
| calendar.add(Calendar.DAY_OF_MONTH, 1); |
| } |
| |
| return calendar.getTime(); |
| } |
| |
| } |
| |
| public static final class DateParseException extends ParseException { |
| |
| public DateParseException(String message) { |
| super(message, 0); |
| } |
| |
| } |
| |
| } |
