Java tutorial
/* * Copyright 2008 Google Inc. * * Licensed 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 com.google.gwt.i18n.shared; import com.google.gwt.i18n.client.LocaleInfo; import com.google.gwt.i18n.shared.impl.DateRecord; import java.util.ArrayList; import java.util.Date; import java.util.HashMap; import java.util.Map; /** * Formats and parses dates and times using locale-sensitive patterns. * * <h3>Patterns</h3> * * <table> * <tr> * <th>Symbol</th> * <th>Meaning</th> * <th>Presentation</th> * <th>Example</th> * </tr> * * <tr> * <td><code>G</code></td> * <td>era designator</td> * <td>Text</td> * <td><code>AD</code></td> * </tr> * * <tr> * <td><code>y</code></td> * <td>year</td> * <td>Number</td> * <td><code>1996</code></td> * </tr> * * <tr> * <td><code>L</code></td> * <td>standalone month in year</td> * <td>Text or Number</td> * <td><code>July (or) 07</code></td> * </tr> * * <tr> * <td><code>M</code></td> * <td>month in year</td> * <td>Text or Number</td> * <td><code>July (or) 07</code></td> * </tr> * * <tr> * <td><code>d</code></td> * <td>day in month</td> * <td>Number</td> * <td><code>10</code></td> * </tr> * * <tr> * <td><code>h</code></td> * <td>hour in am/pm (1-12)</td> * <td>Number</td> * <td><code>12</code></td> * </tr> * * <tr> * <td><code>H</code></td> * <td>hour in day (0-23)</td> * <td>Number</td> * <td><code>0</code></td> * </tr> * * <tr> * <td><code>m</code></td> * <td>minute in hour</td> * <td>Number</td> * <td><code>30</code></td> * </tr> * * <tr> * <td><code>s</code></td> * <td>second in minute</td> * <td>Number</td> * <td><code>55</code></td> * </tr> * * <tr> * <td><code>S</code></td> * <td>fractional second</td> * <td>Number</td> * <td><code>978</code></td> * </tr> * * <tr> * <td><code>E</code></td> * <td>day of week</td> * <td>Text</td> * <td><code>Tuesday</code></td> * </tr> * * <tr> * <td><code>c</code></td> * <td>standalone day of week</td> * <td>Text</td> * <td><code>Tuesday</code></td> * </tr> * * <tr> * <td><code>a</code></td> * <td>am/pm marker</td> * <td>Text</td> * <td><code>PM</code></td> * </tr> * * <tr> * <td><code>k</code></td> * <td>hour in day (1-24)</td> * <td>Number</td> * <td><code>24</code></td> * </tr> * * <tr> * <td><code>K</code></td> * <td>hour in am/pm (0-11)</td> * <td>Number</td> * <td><code>0</code></td> * </tr> * * <tr> * <td><code>z</code></td> * <td>time zone</td> * <td>Text</td> * <td><code>Pacific Standard Time(see comment)</code></td> * </tr> * * <tr> * <td><code>Z</code></td> * <td>time zone (RFC 822)</td> * <td>Text</td> * <td><code>-0800(See comment)</code></td> * </tr> * * <tr> * <td><code>v</code></td> * <td>time zone id</td> * <td>Text</td> * <td><code>America/Los_Angeles(See comment)</code></td> * </tr> * * <tr> * <td><code>'</code></td> * <td>escape for text</td> * <td>Delimiter</td> * <td><code>'Date='</code></td> * </tr> * * <tr> * <td><code>''</code></td> * <td>single quote</td> * <td>Literal</td> * <td><code>'o''clock'</code></td> * </tr> * </table> * * <p> * The number of pattern letters influences the format, as follows: * </p> * * <dl> * <dt>Text</dt> * <dd>if 4 or more, then use the full form; if less than 4, use short or * abbreviated form if it exists (e.g., <code>"EEEE"</code> produces * <code>"Monday"</code>, <code>"EEE"</code> produces <code>"Mon"</code>)</dd> * * <dt>Number</dt> * <dd>the minimum number of digits. Shorter numbers are zero-padded to this * amount (e.g. if <code>"m"</code> produces <code>"6"</code>, <code>"mm"</code> * produces <code>"06"</code>). Year is handled specially; that is, if the count * of 'y' is 2, the Year will be truncated to 2 digits. (e.g., if * <code>"yyyy"</code> produces <code>"1997"</code>, <code>"yy"</code> produces * <code>"97"</code>.) Unlike other fields, fractional seconds are padded on the * right with zero.</dd> * * <dt>Text or Number</dt> * <dd>3 or more, use text, otherwise use number. (e.g. <code>"M"</code> * produces <code>"1"</code>, <code>"MM"</code> produces <code>"01"</code>, * <code>"MMM"</code> produces <code>"Jan"</code>, and <code>"MMMM"</code> * produces <code>"January"</code>. Some pattern letters also treat a count * of 5 specially, meaning a single-letter abbreviation: <code>L</code>, * <code>M</code>, <code>E</code>, and <code>c</code>.</dd> * </dl> * * <p> * Any characters in the pattern that are not in the ranges of ['<code>a</code> * '..'<code>z</code>'] and ['<code>A</code>'..'<code>Z</code>'] will be treated * as quoted text. For instance, characters like '<code>:</code>', ' * <code>.</code>', '<code> </code>' (space), '<code>#</code>' and ' * <code>@</code>' will appear in the resulting time text even they are not * embraced within single quotes. * </p> * * <p> * [Time Zone Handling] Web browsers don't provide all the information we need * for proper time zone formating -- so GWT has a copy of the required data, for * your convenience. For simpler cases, one can also use a fallback * implementation that only keeps track of the current timezone offset. These * two approaches are called, respectively, Common TimeZones and Simple * TimeZones, although both are implemented with the same TimeZone class. * * "TimeZone createTimeZone(String timezoneData)" returns a Common TimeZone * object, and "TimeZone createTimeZone(int timeZoneOffsetInMinutes)" returns a * Simple TimeZone object. The one provided by OS fall into to Simple TimeZone * category. For formatting purpose, following table shows the behavior of GWT * DateTimeFormat. * </p> * <table> * <tr> * <th>Pattern</th> * <th>Common TimeZone</th> * <th>Simple TimeZone</th> * </tr> * <tr> * <td>z, zz, zzz</td> * <td>PDT</td> * <td>UTC-7</td> * </tr> * <tr> * <td>zzzz</td> * <td>Pacific Daylight Time</td> * <td>UTC-7</td> * </tr> * <tr> * <td>Z, ZZ</td> * <td>-0700</td> * <td>-0700</td> * </tr> * <tr> * <td>ZZZ</td> * <td>-07:00</td> * <td>-07:00</td> * </tr> * <tr> * <td>ZZZZ</td> * <td>GMT-07:00</td> * <td>GMT-07:00</td> * </tr> * <tr> * <td>v, vv, vvv, vvvv</td> * <td>America/Los_Angeles</td> * <td>Etc/GMT+7</td> * </tr> * </table> * * <h3>Parsing Dates and Times</h3> * <p> * The pattern does not need to specify every field. If the year, month, or * day is missing from the pattern, the corresponding value will be taken from * the current date. If the month is specified but the day is not, the day will * be constrained to the last day within the specified month. If the hour, * minute, or second is missing, the value defaults to zero. * </p> * * <p> * As with formatting (described above), the count of pattern letters determines * the parsing behavior. * </p> * * <dl> * <dt>Text</dt> * <dd>4 or more pattern letters--use full form, less than 4--use short or * abbreviated form if one exists. In parsing, we will always try long format, * then short.</dd> * * <dt>Number</dt> * <dd>the minimum number of digits.</dd> * * <dt>Text or Number</dt> * <dd>3 or more characters means use text, otherwise use number</dd> * </dl> * * <p> * Although the current pattern specification doesn't not specify behavior for * all letters, it may in the future. It is strongly discouraged to use * unspecified letters as literal text without quoting them. * </p> * <p> * [Note on TimeZone] The time zone support for parsing is limited. Only * standard GMT and RFC format are supported. Time zone specification using time * zone id (like America/Los_Angeles), time zone names (like PST, Pacific * Standard Time) are not supported. Normally, it is too much a burden for a * client application to load all the time zone symbols. And in almost all those * cases, it is a better choice to do such parsing on server side through * certain RPC mechanism. This decision is based on particular use cases we have * studied; in principle, it could be changed in future versions. * </p> * * <h3>Examples</h3> * <table> * <tr> * <th>Pattern</th> * <th>Formatted Text</th> * </tr> * * <tr> * <td><code>"yyyy.MM.dd G 'at' HH:mm:ss vvvv"</code></td> * <td><code>1996.07.10 AD at 15:08:56 America/Los_Angeles</code></td> * </tr> * * <tr> * <td><code>"EEE, MMM d, ''yy"</code></td> * <td><code>Wed, July 10, '96</code></td> * </tr> * * <tr> * <td><code>"h:mm a"</code></td> * <td><code>12:08 PM</code></td> * </tr> * * <tr> * <td><code>"hh 'o''clock' a, zzzz"</code></td> * <td><code> 12 o'clock PM, Pacific Daylight Time</code></td> * </tr> * * <tr> * <td><code>"K:mm a, vvvv"</code></td> * <td><code> 0:00 PM, America/Los_Angeles</code></td> * </tr> * * <tr> * <td><code>"yyyyy.MMMMM.dd GGG hh:mm aaa"</code></td> * <td><code>01996.July.10 AD 12:08 PM</code></td> * </tr> * </table> * * <h3>Additional Parsing Considerations</h3> * <p> * When parsing a date string using the abbreviated year pattern ( * <code>"yy"</code>), the parser must interpret the abbreviated year relative * to some century. It does this by adjusting dates to be within 80 years before * and 20 years after the time the parser instance is created. For example, * using a pattern of <code>"MM/dd/yy"</code> and a <code>DateTimeFormat</code> * object created on Jan 1, 1997, the string <code>"01/11/12"</code> would be * interpreted as Jan 11, 2012 while the string <code>"05/04/64"</code> would be * interpreted as May 4, 1964. During parsing, only strings consisting of * exactly two digits, as defined by {@link java.lang.Character#isDigit(char)}, * will be parsed into the default century. If the year pattern does not have * exactly two 'y' characters, the year is interpreted literally, regardless of * the number of digits. For example, using the pattern * <code>"MM/dd/yyyy"</code>, "01/11/12" parses to Jan 11, 12 A.D. * </p> * * <p> * When numeric fields abut one another directly, with no intervening delimiter * characters, they constitute a run of abutting numeric fields. Such runs are * parsed specially. For example, the format "HHmmss" parses the input text * "123456" to 12:34:56, parses the input text "12345" to 1:23:45, and fails to * parse "1234". In other words, the leftmost field of the run is flexible, * while the others keep a fixed width. If the parse fails anywhere in the run, * then the leftmost field is shortened by one character, and the entire run is * parsed again. This is repeated until either the parse succeeds or the * leftmost field is one character in length. If the parse still fails at that * point, the parse of the run fails. * </p> * * <p> * In the current implementation, timezone parsing only supports * <code>GMT:hhmm</code>, <code>GMT:+hhmm</code>, and <code>GMT:-hhmm</code>. * </p> * * <h3>Example</h3> {@example com.google.gwt.examples.DateTimeFormatExample} * */ public class DateTimeFormat { /** * Predefined date/time formats -- see {@link CustomDateTimeFormat} if you * need some format that isn't supplied here. */ public enum PredefinedFormat { // TODO(jat): Javadoc to explain these formats /** * ISO 8601 date format, fixed across all locales. * <p>Example: {@code 2008-10-03T10:29:40.046-04:00} * <p>http://code.google.com/p/google-web-toolkit/issues/detail?id=3068 * <p>http://www.iso.org/iso/support/faqs/faqs_widely_used_standards/widely_used_standards_other/date_and_time_format.htm */ ISO_8601, /** * RFC 2822 date format, fixed across all locales. * <p>Example: {@code Thu, 20 May 2010 17:54:50 -0700} * <p>http://tools.ietf.org/html/rfc2822#section-3.3 */ RFC_2822, DATE_FULL, DATE_LONG, DATE_MEDIUM, DATE_SHORT, TIME_FULL, TIME_LONG, TIME_MEDIUM, TIME_SHORT, DATE_TIME_FULL, DATE_TIME_LONG, DATE_TIME_MEDIUM, DATE_TIME_SHORT, DAY, HOUR_MINUTE, HOUR_MINUTE_SECOND, HOUR24_MINUTE, HOUR24_MINUTE_SECOND, MINUTE_SECOND, MONTH, MONTH_ABBR, MONTH_ABBR_DAY, MONTH_DAY, MONTH_NUM_DAY, MONTH_WEEKDAY_DAY, YEAR, YEAR_MONTH, YEAR_MONTH_ABBR, YEAR_MONTH_ABBR_DAY, YEAR_MONTH_DAY, YEAR_MONTH_NUM, YEAR_MONTH_NUM_DAY, YEAR_MONTH_WEEKDAY_DAY, YEAR_QUARTER, YEAR_QUARTER_ABBR, } /** * Class PatternPart holds a "compiled" pattern part. */ private static class PatternPart { public String text; public int count; // 0 has a special meaning, it stands for literal public boolean abutStart; public PatternPart(String txt, int cnt) { text = txt; count = cnt; abutStart = false; } } protected static final String RFC2822_PATTERN = "EEE, d MMM yyyy HH:mm:ss Z"; protected static final String ISO8601_PATTERN = "yyyy-MM-dd'T'HH:mm:ss.SSSZZZ"; private static final int NUMBER_BASE = 10; private static final int JS_START_YEAR = 1900; private static final Map<String, DateTimeFormat> cache; private static final int NUM_MILLISECONDS_IN_DAY = 24 * 60 * 60000; private static final String PATTERN_CHARS = "GyMLdkHmsSEcDahKzZv"; // Note: M & L must be the first two characters private static final String NUMERIC_FORMAT_CHARS = "MLydhHmsSDkK"; private static final String WHITE_SPACE = " \t\r\n"; private static final String GMT = "GMT"; private static final String UTC = "UTC"; private static final int MINUTES_PER_HOUR = 60; static { cache = new HashMap<String, DateTimeFormat>(); } /** * Get a DateTimeFormat instance for a predefined format. * * <p>See {@link CustomDateTimeFormat} if you need a localized format that is * not supported here. * * @param predef {@link PredefinedFormat} describing desired format * @return a DateTimeFormat instance for the specified format */ public static DateTimeFormat getFormat(PredefinedFormat predef) { if (usesFixedEnglishStrings(predef)) { String pattern; switch (predef) { case RFC_2822: pattern = RFC2822_PATTERN; break; case ISO_8601: pattern = ISO8601_PATTERN; break; default: throw new IllegalStateException("Unexpected predef type " + predef); } return getFormat(pattern, new DefaultDateTimeFormatInfo()); } DateTimeFormatInfo dtfi = getDefaultDateTimeFormatInfo(); String pattern; switch (predef) { case DATE_FULL: pattern = dtfi.dateFormatFull(); break; case DATE_LONG: pattern = dtfi.dateFormatLong(); break; case DATE_MEDIUM: pattern = dtfi.dateFormatMedium(); break; case DATE_SHORT: pattern = dtfi.dateFormatShort(); break; case DATE_TIME_FULL: pattern = dtfi.dateTimeFull(dtfi.timeFormatFull(), dtfi.dateFormatFull()); break; case DATE_TIME_LONG: pattern = dtfi.dateTimeLong(dtfi.timeFormatLong(), dtfi.dateFormatLong()); break; case DATE_TIME_MEDIUM: pattern = dtfi.dateTimeMedium(dtfi.timeFormatMedium(), dtfi.dateFormatMedium()); break; case DATE_TIME_SHORT: pattern = dtfi.dateTimeShort(dtfi.timeFormatShort(), dtfi.dateFormatShort()); break; case DAY: pattern = dtfi.formatDay(); break; case HOUR24_MINUTE: pattern = dtfi.formatHour24Minute(); break; case HOUR24_MINUTE_SECOND: pattern = dtfi.formatHour24MinuteSecond(); break; case HOUR_MINUTE: pattern = dtfi.formatHour12Minute(); break; case HOUR_MINUTE_SECOND: pattern = dtfi.formatHour12MinuteSecond(); break; case MINUTE_SECOND: pattern = dtfi.formatMinuteSecond(); break; case MONTH: pattern = dtfi.formatMonthFull(); break; case MONTH_ABBR: pattern = dtfi.formatMonthAbbrev(); break; case MONTH_ABBR_DAY: pattern = dtfi.formatMonthAbbrevDay(); break; case MONTH_DAY: pattern = dtfi.formatMonthFullDay(); break; case MONTH_NUM_DAY: pattern = dtfi.formatMonthNumDay(); break; case MONTH_WEEKDAY_DAY: pattern = dtfi.formatMonthFullWeekdayDay(); break; case TIME_FULL: pattern = dtfi.timeFormatFull(); break; case TIME_LONG: pattern = dtfi.timeFormatLong(); break; case TIME_MEDIUM: pattern = dtfi.timeFormatMedium(); break; case TIME_SHORT: pattern = dtfi.timeFormatShort(); break; case YEAR: pattern = dtfi.formatYear(); break; case YEAR_MONTH: pattern = dtfi.formatYearMonthFull(); break; case YEAR_MONTH_ABBR: pattern = dtfi.formatYearMonthAbbrev(); break; case YEAR_MONTH_ABBR_DAY: pattern = dtfi.formatYearMonthAbbrevDay(); break; case YEAR_MONTH_DAY: pattern = dtfi.formatYearMonthFullDay(); break; case YEAR_MONTH_NUM: pattern = dtfi.formatYearMonthNum(); break; case YEAR_MONTH_NUM_DAY: pattern = dtfi.formatYearMonthNumDay(); break; case YEAR_MONTH_WEEKDAY_DAY: pattern = dtfi.formatYearMonthWeekdayDay(); break; case YEAR_QUARTER: pattern = dtfi.formatYearQuarterFull(); break; case YEAR_QUARTER_ABBR: pattern = dtfi.formatYearQuarterShort(); break; default: throw new IllegalArgumentException("Unexpected predefined format " + predef); } return getFormat(pattern, dtfi); } /** * Returns a DateTimeFormat object using the specified pattern. If you need to * format or parse repeatedly using the same pattern, it is highly recommended * that you cache the returned <code>DateTimeFormat</code> object and reuse it * rather than calling this method repeatedly. * * <p>Note that the pattern supplied is used as-is -- for example, if you * supply "MM/dd/yyyy" as the pattern, that is the order you will get the * fields, even in locales where the order is different. It is recommended to * use {@link #getFormat(PredefinedFormat)} instead -- if you use this method, * you are taking responsibility for localizing the patterns yourself. * * @param pattern string to specify how the date should be formatted * * @return a <code>DateTimeFormat</code> object that can be used for format or * parse date/time values matching the specified pattern * * @throws IllegalArgumentException if the specified pattern could not be * parsed */ public static DateTimeFormat getFormat(String pattern) { return getFormat(pattern, getDefaultDateTimeFormatInfo()); } /** * Internal factory method that provides caching. * * @param pattern * @param dtfi * @return DateTimeFormat instance */ protected static DateTimeFormat getFormat(String pattern, DateTimeFormatInfo dtfi) { DateTimeFormatInfo defaultDtfi = getDefaultDateTimeFormatInfo(); DateTimeFormat dtf = null; if (dtfi == defaultDtfi) { dtf = cache.get(pattern); } if (dtf == null) { dtf = new DateTimeFormat(pattern, dtfi); if (dtfi == defaultDtfi) { cache.put(pattern, dtf); } } return dtf; } private static DateTimeFormatInfo getDefaultDateTimeFormatInfo() { // MUSTFIX(jat): implement return LocaleInfo.getCurrentLocale().getDateTimeFormatInfo(); } /** * Returns true if the predefined format is one that specifies always using * English names/separators. * <p>This should be a method on PredefinedFormat, but that would defeat the * enum optimizations GWT is currently capable of. * @param predef * @return true if the specified format requires English names/separators */ private static boolean usesFixedEnglishStrings(PredefinedFormat predef) { switch (predef) { case RFC_2822: return true; case ISO_8601: return true; default: return false; } } private final ArrayList<PatternPart> patternParts = new ArrayList<PatternPart>(); private final DateTimeFormatInfo dateTimeFormatInfo; private final String pattern; /** * Constructs a format object using the specified pattern and the date time * constants for the default locale. * * @param pattern string pattern specification */ protected DateTimeFormat(String pattern) { this(pattern, getDefaultDateTimeFormatInfo()); } /** * Constructs a format object using the specified pattern and user-supplied * date time constants. * * @param pattern string pattern specification * @param dtfi DateTimeFormatInfo instance to use */ protected DateTimeFormat(String pattern, DateTimeFormatInfo dtfi) { this.pattern = pattern; this.dateTimeFormatInfo = dtfi; /* * Even though the pattern is only compiled for use in parsing and parsing * is far less common than formatting, the pattern is still parsed eagerly * here to fail fast in case the pattern itself is malformed. */ parsePattern(pattern); } /** * Format a date object. * * @param date the date object being formatted * * @return string representation for this date in desired format */ public String format(Date date) { return format(date, null); } /** * Format a date object using specified time zone. * * @param date the date object being formatted * @param timeZone a TimeZone object that holds time zone information, or * {@code null} to use the default * * @return string representation for this date in the format defined by this * object */ @SuppressWarnings("deprecation") public String format(Date date, TimeZone timeZone) { // We use the Date class to calculate each date/time field in order // to maximize performance and minimize code size. // JavaScript only provides an API for rendering local time (in the os time // zone). Here we want to render time in any timezone. So suppose we try to // render the date (20:00 GMT0000, or 16:00 GMT-0400, or 12:00 GMT-0800) for // time zone GMT-0400, and OS has time zone GMT-0800. By adding the // difference between OS time zone (GMT-0800) and target time zone // (GMT-0400) to "date", we end up with 16:00 GMT-0800. This date object // has the same date/time fields (year, month, date, hour, minutes, etc) // in GMT-0800 as original date in our target time zone (GMT-0400). We // just need to take care of time zone display, but that's needed anyway. // Things get a little bit more tricky when a daylight time transition // happens. For example, if the OS timezone is America/Los_Angeles, // it is just impossible to have a Date represent 2006/4/2 02:30, because // 2:00 to 3:00 on that day does not exist in US Pacific time zone because // of the daylight time switch. // But we can use 2 separate date objects, one to represent 2006/4/2, one // to represent 02:30. Of course, for the 2nd date object its date can be // any other day in that year, except 2006/4/2. So we end up have 3 Date // objects: one for resolving "Year, month, day", one for time within that // day, and the original date object, which is needed for figuring out // actual time zone offset. if (timeZone == null) { timeZone = createTimeZone(date.getTimezoneOffset()); } int diff = (date.getTimezoneOffset() - timeZone.getOffset(date)) * 60000; Date keepDate = new Date(date.getTime() + diff); Date keepTime = keepDate; if (keepDate.getTimezoneOffset() != date.getTimezoneOffset()) { if (diff > 0) { diff -= NUM_MILLISECONDS_IN_DAY; } else { diff += NUM_MILLISECONDS_IN_DAY; } keepTime = new Date(date.getTime() + diff); } StringBuffer toAppendTo = new StringBuffer(64); int j, n = pattern.length(); for (int i = 0; i < n;) { char ch = pattern.charAt(i); if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) { // ch is a date-time pattern character to be interpreted by subFormat(). // Count the number of times it is repeated. for (j = i + 1; j < n && pattern.charAt(j) == ch; ++j) { } subFormat(toAppendTo, ch, j - i, date, keepDate, keepTime, timeZone); i = j; } else if (ch == '\'') { // Handle an entire quoted string, included embedded // doubled apostrophes (as in 'o''clock'). // i points after '. ++i; // If start with '', just add ' and continue. if (i < n && pattern.charAt(i) == '\'') { toAppendTo.append('\''); ++i; continue; } // Otherwise add the quoted string. boolean trailQuote = false; while (!trailQuote) { // j points to next ' or EOS. j = i; while (j < n && pattern.charAt(j) != '\'') { ++j; } if (j >= n) { // Trailing ' (pathological). throw new IllegalArgumentException("Missing trailing \'"); } // Look ahead to detect '' within quotes. if (j + 1 < n && pattern.charAt(j + 1) == '\'') { ++j; } else { trailQuote = true; } toAppendTo.append(pattern.substring(i, j)); i = j + 1; } } else { // Append unquoted literal characters. toAppendTo.append(ch); ++i; } } return toAppendTo.toString(); } /** * Retrieve the pattern used in this DateTimeFormat object. * * @return pattern string */ public String getPattern() { return pattern; } /** * Parses text to produce a {@link Date} value. An * {@link IllegalArgumentException} is thrown if either the text is empty or * if the parse does not consume all characters of the text. * * Dates are parsed leniently, so invalid dates will be wrapped around as * needed. For example, February 30 will wrap to March 2. * * @param text the string being parsed * @return a parsed date/time value * @throws IllegalArgumentException if the entire text could not be converted * into a number */ public Date parse(String text) throws IllegalArgumentException { return parse(text, false); } /** * This method modifies a {@link Date} object to reflect the date that is * parsed from an input string. * * Dates are parsed leniently, so invalid dates will be wrapped around as * needed. For example, February 30 will wrap to March 2. * * @param text the string that need to be parsed * @param start the character position in "text" where parsing should start * @param date the date object that will hold parsed value * * @return 0 if parsing failed, otherwise the number of characters advanced */ public int parse(String text, int start, Date date) { return parse(text, start, date, false); } /** * Parses text to produce a {@link Date} value. An * {@link IllegalArgumentException} is thrown if either the text is empty or * if the parse does not consume all characters of the text. * * Dates are parsed strictly, so invalid dates will result in an * {@link IllegalArgumentException}. * * @param text the string being parsed * @return a parsed date/time value * @throws IllegalArgumentException if the entire text could not be converted * into a number */ public Date parseStrict(String text) throws IllegalArgumentException { return parse(text, true); } /** * This method modifies a {@link Date} object to reflect the date that is * parsed from an input string. * * Dates are parsed strictly, so invalid dates will return 0. For example, * February 30 will return 0 because February only has 28 days. * * @param text the string that need to be parsed * @param start the character position in "text" where parsing should start * @param date the date object that will hold parsed value * * @return 0 if parsing failed, otherwise the number of characters advanced */ public int parseStrict(String text, int start, Date date) { return parse(text, start, date, true); } /** * @param timezoneOffset * @return {@link TimeZone} instance */ protected TimeZone createTimeZone(int timezoneOffset) { // MUSTFIX(jat): implement return com.google.gwt.i18n.client.TimeZone.createTimeZone(timezoneOffset); } /** * Method append current content in buf as pattern part if there is any, and * clear buf for next part. * * @param buf pattern part text specification * @param count pattern part repeat count */ private void addPart(StringBuffer buf, int count) { if (buf.length() > 0) { patternParts.add((new PatternPart(buf.toString(), count))); buf.setLength(0); } } /** * Formats (0..11) Hours field according to pattern specified. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ @SuppressWarnings("deprecation") private void format0To11Hours(StringBuffer buf, int count, Date date) { int value = date.getHours() % 12; zeroPaddingNumber(buf, value, count); } /** * Formats (0..23) Hours field according to pattern specified. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ @SuppressWarnings("deprecation") private void format0To23Hours(StringBuffer buf, int count, Date date) { int value = date.getHours(); zeroPaddingNumber(buf, value, count); } /** * Formats (1..12) Hours field according to pattern specified. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ @SuppressWarnings("deprecation") private void format1To12Hours(StringBuffer buf, int count, Date date) { int value = date.getHours() % 12; if (value == 0) { zeroPaddingNumber(buf, 12, count); } else { zeroPaddingNumber(buf, value, count); } } /** * Formats (1..24) Hours field according to pattern specified. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ @SuppressWarnings("deprecation") private void format24Hours(StringBuffer buf, int count, Date date) { int value = date.getHours(); if (value == 0) { zeroPaddingNumber(buf, 24, count); } else { zeroPaddingNumber(buf, value, count); } } /** * Formats AM/PM field according to pattern specified. * * @param buf where formatted string will be appended to * @param date hold the date object to be formatted */ @SuppressWarnings("deprecation") private void formatAmPm(StringBuffer buf, Date date) { if (date.getHours() >= 12 && date.getHours() < 24) { buf.append(dateTimeFormatInfo.ampms()[1]); } else { buf.append(dateTimeFormatInfo.ampms()[0]); } } /** * Formats Date field according to pattern specified. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ private void formatDate(StringBuffer buf, int count, Date date) { @SuppressWarnings("deprecation") int value = date.getDate(); zeroPaddingNumber(buf, value, count); } /** * Formats Day of week field according to pattern specified. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ private void formatDayOfWeek(StringBuffer buf, int count, Date date) { @SuppressWarnings("deprecation") int value = date.getDay(); if (count == 5) { buf.append(dateTimeFormatInfo.weekdaysNarrow()[value]); } else if (count == 4) { buf.append(dateTimeFormatInfo.weekdaysFull()[value]); } else { buf.append(dateTimeFormatInfo.weekdaysShort()[value]); } } /** * Formats Era field according to pattern specified. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ private void formatEra(StringBuffer buf, int count, Date date) { @SuppressWarnings("deprecation") int value = date.getYear() >= -JS_START_YEAR ? 1 : 0; if (count >= 4) { buf.append(dateTimeFormatInfo.erasFull()[value]); } else { buf.append(dateTimeFormatInfo.erasShort()[value]); } } /** * Formats Fractional seconds field according to pattern specified. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ private void formatFractionalSeconds(StringBuffer buf, int count, Date date) { /* * Fractional seconds should be left-justified, ie. zero must be padded from * left. For example, if the value in milliseconds is 5, and the count is 3, * the output will be "005". * * Values with less than three digits are rounded to the desired number of * places, but the rounded values are truncated at 9 or 99 in order to avoid * changing the values of seconds. */ long time = date.getTime(); int value; if (time < 0) { value = 1000 - (int) (-time % 1000); if (value == 1000) { value = 0; } } else { value = (int) (time % 1000); } if (count == 1) { value = Math.min((value + 50) / 100, 9); // Round to 100ms, clamp to 9 buf.append((char) ('0' + value)); } else if (count == 2) { value = Math.min((value + 5) / 10, 99); // Round to 10ms, clamp to 99 zeroPaddingNumber(buf, value, 2); } else { zeroPaddingNumber(buf, value, 3); if (count > 3) { zeroPaddingNumber(buf, 0, count - 3); } } } /** * Formats Minutes field according to pattern specified. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ private void formatMinutes(StringBuffer buf, int count, Date date) { @SuppressWarnings("deprecation") int value = date.getMinutes(); zeroPaddingNumber(buf, value, count); } /** * Formats Month field according to pattern specified. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ private void formatMonth(StringBuffer buf, int count, Date date) { @SuppressWarnings("deprecation") int value = date.getMonth(); switch (count) { case 5: buf.append(dateTimeFormatInfo.monthsNarrow()[value]); break; case 4: buf.append(dateTimeFormatInfo.monthsFull()[value]); break; case 3: buf.append(dateTimeFormatInfo.monthsShort()[value]); break; default: zeroPaddingNumber(buf, value + 1, count); } } /** * Formats Quarter field according to pattern specified. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ private void formatQuarter(StringBuffer buf, int count, Date date) { @SuppressWarnings("deprecation") int value = date.getMonth() / 3; if (count < 4) { buf.append(dateTimeFormatInfo.quartersShort()[value]); } else { buf.append(dateTimeFormatInfo.quartersFull()[value]); } } /** * Formats Seconds field according to pattern specified. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ private void formatSeconds(StringBuffer buf, int count, Date date) { @SuppressWarnings("deprecation") int value = date.getSeconds(); zeroPaddingNumber(buf, value, count); } /** * Formats Standalone weekday field according to pattern specified. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ private void formatStandaloneDay(StringBuffer buf, int count, Date date) { @SuppressWarnings("deprecation") int value = date.getDay(); if (count == 5) { buf.append(dateTimeFormatInfo.weekdaysNarrowStandalone()[value]); } else if (count == 4) { buf.append(dateTimeFormatInfo.weekdaysFullStandalone()[value]); } else if (count == 3) { buf.append(dateTimeFormatInfo.weekdaysShortStandalone()[value]); } else { zeroPaddingNumber(buf, value, 1); } } /** * Formats Standalone Month field according to pattern specified. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ private void formatStandaloneMonth(StringBuffer buf, int count, Date date) { @SuppressWarnings("deprecation") int value = date.getMonth(); if (count == 5) { buf.append(dateTimeFormatInfo.monthsNarrowStandalone()[value]); } else if (count == 4) { buf.append(dateTimeFormatInfo.monthsFullStandalone()[value]); } else if (count == 3) { buf.append(dateTimeFormatInfo.monthsShortStandalone()[value]); } else { zeroPaddingNumber(buf, value + 1, count); } } /** * Formats Timezone field. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ private void formatTimeZone(StringBuffer buf, int count, Date date, TimeZone timeZone) { if (count < 4) { buf.append(timeZone.getShortName(date)); } else { buf.append(timeZone.getLongName(date)); } } /** * Formats Timezone field following RFC. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date hold the date object to be formatted */ private void formatTimeZoneRFC(StringBuffer buf, int count, Date date, TimeZone timeZone) { if (count < 3) { buf.append(timeZone.getRFCTimeZoneString(date)); } else if (count == 3) { buf.append(timeZone.getISOTimeZoneString(date)); } else { buf.append(timeZone.getGMTString(date)); } } /** * Formats Year field according to pattern specified. Javascript Date object * seems incapable handling 1BC and year before. It can show you year 0 which * does not exists. following we just keep consistent with javascript's * toString method. But keep in mind those things should be unsupported. * * @param buf where formatted string will be appended to * @param count number of time pattern char repeats; this controls how a field * should be formatted; 2 is treated specially with the last two digits of * the year, while more than 2 digits are zero-padded * @param date hold the date object to be formatted */ private void formatYear(StringBuffer buf, int count, Date date) { @SuppressWarnings("deprecation") int value = date.getYear() + JS_START_YEAR; if (value < 0) { value = -value; } switch (count) { case 1: // no padding buf.append(value); break; case 2: // last 2 digits of year, zero-padded zeroPaddingNumber(buf, value % 100, 2); break; default: // anything else is zero-padded zeroPaddingNumber(buf, value, count); break; } } /** * Method getNextCharCountInPattern calculate character repeat count in * pattern. * * @param pattern describe the format of date string that need to be parsed * @param start the position of pattern character * @return repeat count */ private int getNextCharCountInPattern(String pattern, int start) { char ch = pattern.charAt(start); int next = start + 1; while (next < pattern.length() && pattern.charAt(next) == ch) { ++next; } return next - start; } /** * Method identifies the start of a run of abutting numeric fields. Take the * pattern "HHmmss" as an example. We will try to parse 2/2/2 characters of * the input text, then if that fails, 1/2/2. We only adjust the width of the * leftmost field; the others remain fixed. This allows "123456" => 12:34:56, * but "12345" => 1:23:45. Likewise, for the pattern "yyyyMMdd" we try 4/2/2, * 3/2/2, 2/2/2, and finally 1/2/2. The first field of connected numeric * fields will be marked as abutStart, its width can be reduced to accomodate * others. */ private void identifyAbutStart() { // 'abut' parts are continuous numeric parts. abutStart is the switch // point from non-abut to abut. boolean abut = false; int len = patternParts.size(); for (int i = 0; i < len; i++) { if (isNumeric(patternParts.get(i))) { // If next part is not following abut sequence, and isNumeric. if (!abut && i + 1 < len && isNumeric(patternParts.get(i + 1))) { abut = true; patternParts.get(i).abutStart = true; } } else { abut = false; } } } /** * Method checks if the pattern part is a numeric field. * * @param part pattern part to be examined * @return <code>true</code> if the pattern part is numberic field */ private boolean isNumeric(PatternPart part) { if (part.count <= 0) { return false; } int i = NUMERIC_FORMAT_CHARS.indexOf(part.text.charAt(0)); // M & L (index 0 and 1) are only numeric if there are less than 3 chars return (i > 1 || (i >= 0 && part.count < 3)); } /** * Method attempts to match the text at a given position against an array of * strings. Since multiple strings in the array may match (for example, if the * array contains "a", "ab", and "abc", all will match the input string * "abcd") the longest match is returned. * * @param text the time text being parsed * @param start where to start parsing * @param data the string array to parsed * @param pos to receive where the match stopped * @return the new start position if matching succeeded; a negative number * indicating matching failure */ private int matchString(String text, int start, String[] data, int[] pos) { int count = data.length; // There may be multiple strings in the data[] array which begin with // the same prefix (e.g., Cerven and Cervenec (June and July) in Czech). // We keep track of the longest match, and return that. Note that this // unfortunately requires us to test all array elements. int bestMatchLength = 0, bestMatch = -1; String textInLowerCase = text.substring(start).toLowerCase(); for (int i = 0; i < count; ++i) { int length = data[i].length(); // Always compare if we have no match yet; otherwise only compare // against potentially better matches (longer strings). if (length > bestMatchLength && textInLowerCase.startsWith(data[i].toLowerCase())) { bestMatch = i; bestMatchLength = length; } } if (bestMatch >= 0) { pos[0] = start + bestMatchLength; } return bestMatch; } /** * Parses text to produce a {@link Date} value. An * {@link IllegalArgumentException} is thrown if either the text is empty or * if the parse does not consume all characters of the text. * * If using lenient parsing, certain invalid dates and times will be parsed. * For example, February 32nd would be parsed as March 4th in lenient mode, * but would throw an exception in non-lenient mode. * * @param text the string being parsed * @param strict true to be strict when parsing, false to be lenient * @return a parsed date/time value * @throws IllegalArgumentException if the entire text could not be converted * into a number */ private Date parse(String text, boolean strict) { Date curDate = new Date(); @SuppressWarnings("deprecation") Date date = new Date(curDate.getYear(), curDate.getMonth(), curDate.getDate()); int charsConsumed = parse(text, 0, date, strict); if (charsConsumed == 0 || charsConsumed < text.length()) { throw new IllegalArgumentException(text); } return date; } /** * This method parses the input string and fills its value into a {@link Date} * . * * If using lenient parsing, certain invalid dates and times will be parsed. * For example, February 32nd would be parsed as March 4th in lenient mode, * but would return 0 in non-lenient mode. * * @param text the string that need to be parsed * @param start the character position in "text" where parsing should start * @param date the date object that will hold parsed value * @param strict true to be strict when parsing, false to be lenient * * @return 0 if parsing failed, otherwise the number of characters advanced */ private int parse(String text, int start, Date date, boolean strict) { DateRecord cal = new DateRecord(); int[] parsePos = { start }; // For parsing abutting numeric fields. 'abutPat' is the // offset into 'pattern' of the first of 2 or more abutting // numeric fields. 'abutStart' is the offset into 'text' // where parsing the fields begins. 'abutPass' starts off as 0 // and increments each time we try to parse the fields. int abutPat = -1; // If >=0, we are in a run of abutting numeric fields. int abutStart = 0; int abutPass = 0; for (int i = 0; i < patternParts.size(); ++i) { PatternPart part = patternParts.get(i); if (part.count > 0) { if (abutPat < 0 && part.abutStart) { abutPat = i; abutStart = start; abutPass = 0; } // Handle fields within a run of abutting numeric fields. Take // the pattern "HHmmss" as an example. We will try to parse // 2/2/2 characters of the input text, then if that fails, // 1/2/2. We only adjust the width of the leftmost field; the // others remain fixed. This allows "123456" => 12:34:56, but // "12345" => 1:23:45. Likewise, for the pattern "yyyyMMdd" we // try 4/2/2, 3/2/2, 2/2/2, and finally 1/2/2. if (abutPat >= 0) { // If we are at the start of a run of abutting fields, then // shorten this field in each pass. If we can't shorten // this field any more, then the parse of this set of // abutting numeric fields has failed. int count = part.count; if (i == abutPat) { count -= abutPass++; if (count == 0) { return 0; } } if (!subParse(text, parsePos, part, count, cal)) { // If the parse fails anywhere in the run, back up to the // start of the run and retry. i = abutPat - 1; parsePos[0] = abutStart; continue; } } else { // Handle non-numeric fields and non-abutting numeric fields. abutPat = -1; if (!subParse(text, parsePos, part, 0, cal)) { return 0; } } } else { // Handle literal pattern characters. These are any // quoted characters and non-alphabetic unquoted characters. abutPat = -1; // A run of white space in the pattern matches a run // of white space in the input text. if (part.text.charAt(0) == ' ') { // Advance over run in input text. int s = parsePos[0]; skipSpace(text, parsePos); // Must see at least one white space char in input. if (parsePos[0] > s) { continue; } } else if (text.startsWith(part.text, parsePos[0])) { parsePos[0] += part.text.length(); continue; } // We fall through to this point if the match fails. return 0; } } // Calculate the date from the parts if (!cal.calcDate(date, strict)) { return 0; } // Return progress. return parsePos[0] - start; } /** * Method parses a integer string and return integer value. * * @param text string being parsed * @param pos parse position * * @return integer value */ private int parseInt(String text, int[] pos) { int ret = 0; int ind = pos[0]; if (ind >= text.length()) { return -1; } char ch = text.charAt(ind); while (ch >= '0' && ch <= '9') { ret = ret * 10 + (ch - '0'); ind++; if (ind >= text.length()) { break; } ch = text.charAt(ind); } if (ind > pos[0]) { pos[0] = ind; } else { ret = -1; } return ret; } /** * Method parses the input pattern string a generate a vector of pattern * parts. * * @param pattern describe the format of date string that need to be parsed */ private void parsePattern(String pattern) { StringBuffer buf = new StringBuffer(32); boolean inQuote = false; for (int i = 0; i < pattern.length(); i++) { char ch = pattern.charAt(i); // Handle space, add literal part (if exist), and add space part. if (ch == ' ') { addPart(buf, 0); buf.append(' '); addPart(buf, 0); while (i + 1 < pattern.length() && pattern.charAt(i + 1) == ' ') { i++; } continue; } // If inside quote, except two quote connected, just copy or exit. if (inQuote) { if (ch == '\'') { if (i + 1 < pattern.length() && pattern.charAt(i + 1) == '\'') { // Quote appeared twice continuously, interpret as one quote. buf.append(ch); ++i; } else { inQuote = false; } } else { // Literal. buf.append(ch); } continue; } // Outside quote now. if (PATTERN_CHARS.indexOf(ch) > 0) { addPart(buf, 0); buf.append(ch); int count = getNextCharCountInPattern(pattern, i); addPart(buf, count); i += count - 1; continue; } // Two consecutive quotes is a quote literal, inside or outside of quotes. if (ch == '\'') { if (i + 1 < pattern.length() && pattern.charAt(i + 1) == '\'') { buf.append('\''); i++; } else { inQuote = true; } } else { buf.append(ch); } } addPart(buf, 0); identifyAbutStart(); } /** * Method parses time zone offset. * * @param text the time text to be parsed * @param pos Parse position * @param cal DateRecord object that holds parsed value * * @return <code>true</code> if parsing successful, otherwise * <code>false</code> */ private boolean parseTimeZoneOffset(String text, int[] pos, DateRecord cal) { if (pos[0] >= text.length()) { cal.setTzOffset(0); return true; } int sign; switch (text.charAt(pos[0])) { case '+': sign = 1; break; case '-': sign = -1; break; default: cal.setTzOffset(0); return true; } ++(pos[0]); // Look for hours:minutes or hhmm. int st = pos[0]; int value = parseInt(text, pos); if (value == 0 && pos[0] == st) { return false; } int offset; if (pos[0] < text.length() && text.charAt(pos[0]) == ':') { // This is the hours:minutes case. offset = value * MINUTES_PER_HOUR; ++(pos[0]); st = pos[0]; value = parseInt(text, pos); if (value == 0 && pos[0] == st) { return false; } offset += value; } else { // This is the hhmm case. offset = value; // Assume "-23".."+23" refers to hours. if (offset < 24 && (pos[0] - st) <= 2) { offset *= MINUTES_PER_HOUR; } else { offset = offset % 100 + offset / 100 * MINUTES_PER_HOUR; } } offset *= sign; cal.setTzOffset(-offset); return true; } /** * Method skips space in the string as pointed by pos. * * @param text input string * @param pos where skip start, and return back where skip stop */ private void skipSpace(String text, int[] pos) { while (pos[0] < text.length() && WHITE_SPACE.indexOf(text.charAt(pos[0])) >= 0) { ++(pos[0]); } } /** * Formats a single field according to pattern specified. * * @param ch pattern character for this field * @param count number of time pattern char repeats; this controls how a field * should be formatted * @param date the date object to be formatted * @param adjustedDate holds the time zone adjusted date fields * @param adjustedTime holds the time zone adjusted time fields * * @return <code>true</code> if pattern valid, otherwise <code>false</code> * */ private boolean subFormat(StringBuffer buf, char ch, int count, Date date, Date adjustedDate, Date adjustedTime, TimeZone timezone) { switch (ch) { case 'G': formatEra(buf, count, adjustedDate); break; case 'y': formatYear(buf, count, adjustedDate); break; case 'M': formatMonth(buf, count, adjustedDate); break; case 'k': format24Hours(buf, count, adjustedTime); break; case 'S': formatFractionalSeconds(buf, count, adjustedTime); break; case 'E': formatDayOfWeek(buf, count, adjustedDate); break; case 'a': formatAmPm(buf, adjustedTime); break; case 'h': format1To12Hours(buf, count, adjustedTime); break; case 'K': format0To11Hours(buf, count, adjustedTime); break; case 'H': format0To23Hours(buf, count, adjustedTime); break; case 'c': formatStandaloneDay(buf, count, adjustedDate); break; case 'L': formatStandaloneMonth(buf, count, adjustedDate); break; case 'Q': formatQuarter(buf, count, adjustedDate); break; case 'd': formatDate(buf, count, adjustedDate); break; case 'm': formatMinutes(buf, count, adjustedTime); break; case 's': formatSeconds(buf, count, adjustedTime); break; case 'z': formatTimeZone(buf, count, date, timezone); break; case 'v': buf.append(timezone.getID()); break; case 'Z': formatTimeZoneRFC(buf, count, date, timezone); break; default: return false; } return true; } /** * Converts one field of the input string into a numeric field value. Returns * <code>false</code> if failed. * * @param text the time text to be parsed * @param pos Parse position * @param part the pattern part for this field * @param digitCount when greater than 0, numeric parsing must obey the count * @param cal DateRecord object that will hold parsed value * * @return <code>true</code> if parsing successful */ @SuppressWarnings("fallthrough") private boolean subParse(String text, int[] pos, PatternPart part, int digitCount, DateRecord cal) { skipSpace(text, pos); int start = pos[0]; char ch = part.text.charAt(0); // Parse integer value if it is a numeric field. int value = -1; // initialize value to be -1, if (isNumeric(part)) { if (digitCount > 0) { if ((start + digitCount) > text.length()) { return false; } value = parseInt(text.substring(0, start + digitCount), pos); } else { value = parseInt(text, pos); } } switch (ch) { case 'G': // era value = matchString(text, start, dateTimeFormatInfo.erasFull(), pos); cal.setEra(value); return true; case 'M': // month return subParseMonth(text, pos, cal, value, start); case 'L': // standalone month return subParseStandaloneMonth(text, pos, cal, value, start); case 'E': // day of week return subParseDayOfWeek(text, pos, start, cal); case 'c': // standalone day of week return subParseStandaloneDay(text, pos, start, cal); case 'a': // AM/PM value = matchString(text, start, dateTimeFormatInfo.ampms(), pos); cal.setAmpm(value); return true; case 'y': // year return subParseYear(text, pos, start, value, part, cal); case 'd': // day of month if (value <= 0) { return false; } cal.setDayOfMonth(value); return true; case 'S': // fractional seconds if (value < 0) { return false; } return subParseFractionalSeconds(value, start, pos[0], cal); case 'h': // hour (1..12) if (value == 12) { value = 0; } // fall through case 'K': // hour (0..11) case 'H': // hour (0..23) if (value < 0) { return false; } cal.setHours(value); return true; case 'k': // hour (1..24) if (value < 0) { return false; } cal.setHours(value); return true; case 'm': // minute if (value < 0) { return false; } cal.setMinutes(value); return true; case 's': // second if (value < 0) { return false; } cal.setSeconds(value); return true; case 'z': // time zone offset case 'Z': // time zone RFC case 'v': // time zone generic return subParseTimeZoneInGMT(text, start, pos, cal); default: return false; } } /** * Method subParseDayOfWeek parses day of the week field. * * @param text the time text to be parsed * @param pos Parse position * @param start from where parse start * @param cal DateRecord object that holds parsed value * * @return <code>true</code> if parsing successful, otherwise * <code>false</code> */ private boolean subParseDayOfWeek(String text, int[] pos, int start, DateRecord cal) { int value; // 'E' - DAY_OF_WEEK // Want to be able to parse both short and long forms. // Try count == 4 (DDDD) first: value = matchString(text, start, dateTimeFormatInfo.weekdaysFull(), pos); if (value < 0) { value = matchString(text, start, dateTimeFormatInfo.weekdaysShort(), pos); } if (value < 0) { return false; } cal.setDayOfWeek(value); return true; } /** * Method subParseFractionalSeconds parses fractional seconds field. * * @param value parsed numberic value * @param start * @param end parse position * @param cal DateRecord object that holds parsed value * @return <code>true</code> if parsing successful, otherwise * <code>false</code> */ private boolean subParseFractionalSeconds(int value, int start, int end, DateRecord cal) { // Fractional seconds left-justify. int i = end - start; if (i < 3) { while (i < 3) { value *= 10; i++; } } else { int a = 1; while (i > 3) { a *= 10; i--; } value = (value + (a >> 1)) / a; } cal.setMilliseconds(value); return true; } /** * Parses Month field. * * @param text the time text to be parsed * @param pos Parse position * @param cal DateRecord object that will hold parsed value * @param value numeric value if this field is expressed using numberic * pattern * @param start from where parse start * * @return <code>true</code> if parsing successful */ private boolean subParseMonth(String text, int[] pos, DateRecord cal, int value, int start) { // When month is symbols, i.e., MMM or MMMM, value will be -1. if (value < 0) { // Want to be able to parse both short and long forms. // Try count == 4 first: value = matchString(text, start, dateTimeFormatInfo.monthsFull(), pos); if (value < 0) { // count == 4 failed, now try count == 3. value = matchString(text, start, dateTimeFormatInfo.monthsShort(), pos); } if (value < 0) { return false; } cal.setMonth(value); return true; } else if (value > 0) { cal.setMonth(value - 1); return true; } return false; } /** * Parses standalone day of the week field. * * @param text the time text to be parsed * @param pos Parse position * @param start from where parse start * @param cal DateRecord object that holds parsed value * * @return <code>true</code> if parsing successful, otherwise * <code>false</code> */ private boolean subParseStandaloneDay(String text, int[] pos, int start, DateRecord cal) { int value; // 'c' - DAY_OF_WEEK // Want to be able to parse both short and long forms. // Try count == 4 (cccc) first: value = matchString(text, start, dateTimeFormatInfo.weekdaysFullStandalone(), pos); if (value < 0) { value = matchString(text, start, dateTimeFormatInfo.weekdaysShortStandalone(), pos); } if (value < 0) { return false; } cal.setDayOfWeek(value); return true; } /** * Parses a standalone month field. * * @param text the time text to be parsed * @param pos Parse position * @param cal DateRecord object that will hold parsed value * @param value numeric value if this field is expressed using numberic * pattern * @param start from where parse start * * @return <code>true</code> if parsing successful */ private boolean subParseStandaloneMonth(String text, int[] pos, DateRecord cal, int value, int start) { // When month is symbols, i.e., LLL or LLLL, value will be -1. if (value < 0) { // Want to be able to parse both short and long forms. // Try count == 4 first: value = matchString(text, start, dateTimeFormatInfo.monthsFullStandalone(), pos); if (value < 0) { // count == 4 failed, now try count == 3. value = matchString(text, start, dateTimeFormatInfo.monthsShortStandalone(), pos); } if (value < 0) { return false; } cal.setMonth(value); return true; } else if (value > 0) { cal.setMonth(value - 1); return true; } return false; } /** * Method parses GMT type timezone. * * @param text the time text to be parsed * @param start from where parse start * @param pos Parse position * @param cal DateRecord object that holds parsed value * * @return <code>true</code> if parsing successful, otherwise * <code>false</code> */ private boolean subParseTimeZoneInGMT(String text, int start, int[] pos, DateRecord cal) { // First try to parse generic forms such as GMT-07:00. Do this first // in case localized DateFormatZoneData contains the string "GMT" // for a zone; in that case, we don't want to match the first three // characters of GMT+/-HH:MM etc. // For time zones that have no known names, look for strings // of the form: // GMT[+-]hours:minutes or // GMT[+-]hhmm or // GMT. if (text.startsWith(GMT, start)) { pos[0] = start + GMT.length(); return parseTimeZoneOffset(text, pos, cal); } // Likewise for UTC. if (text.startsWith(UTC, start)) { pos[0] = start + UTC.length(); return parseTimeZoneOffset(text, pos, cal); } // At this point, check for named time zones by looking through // the locale data from the DateFormatZoneData strings. // Want to be able to parse both short and long forms. /* * i = subParseZoneString(text, start, cal); if (i != 0) return i; */ // As a last resort, look for numeric timezones of the form // [+-]hhmm as specified by RFC 822. This code is actually // a little more permissive than RFC 822. It will try to do // its best with numbers that aren't strictly 4 digits long. return parseTimeZoneOffset(text, pos, cal); } /** * Method subParseYear parse year field. Year field is special because 1, two * digit year need to be resolved. 2, we allow year to take a sign. 3, year * field participate in abut processing. In my testing, negative year does not * seem working due to JDK (or GWT implementation) limitation. It is not a * big deal so we don't worry about it. But keep the logic here so that we * might want to replace DateRecord with our a calendar class. * * @param text the time text to be parsed * @param pos parse position * @param start where this field starts * @param value integer value of year * @param part the pattern part for this field * @param cal DateRecord object that will hold parsed value * * @return <code>true</code> if successful */ private boolean subParseYear(String text, int[] pos, int start, int value, PatternPart part, DateRecord cal) { char ch = ' '; if (value < 0) { if (pos[0] >= text.length()) { return false; } ch = text.charAt(pos[0]); // Check if it is a sign. if (ch != '+' && ch != '-') { return false; } ++(pos[0]); value = parseInt(text, pos); if (value < 0) { return false; } if (ch == '-') { value = -value; } } // no sign, only 2 digit was actually parsed, pattern say it has 2 digit. if (ch == ' ' && (pos[0] - start) == 2 && part.count == 2) { // Assume for example that the defaultCenturyStart is 6/18/1903. // This means that two-digit years will be forced into the range // 6/18/1903 to 6/17/2003. As a result, years 00, 01, and 02 // correspond to 2000, 2001, and 2002. Years 04, 05, etc. correspond // to 1904, 1905, etc. If the year is 03, then it is 2003 if the // other fields specify a date before 6/18, or 1903 if they specify a // date afterwards. As a result, 03 is an ambiguous year. All other // two-digit years are unambiguous. Date date = new Date(); @SuppressWarnings("deprecation") int defaultCenturyStartYear = date.getYear() + 1900 - 80; int ambiguousTwoDigitYear = defaultCenturyStartYear % 100; cal.setAmbiguousYear(value == ambiguousTwoDigitYear); value += (defaultCenturyStartYear / 100) * 100 + (value < ambiguousTwoDigitYear ? 100 : 0); } cal.setYear(value); return true; } /** * Formats a number with the specified minimum number of digits, using zero to * fill the gap. * * @param buf where zero padded string will be written to * @param value the number value being formatted * @param minWidth minimum width of the formatted string; zero will be padded * to reach this width */ private void zeroPaddingNumber(StringBuffer buf, int value, int minWidth) { int b = NUMBER_BASE; for (int i = 0; i < minWidth - 1; i++) { if (value < b) { buf.append('0'); } b *= NUMBER_BASE; } buf.append(value); } }