4368 lines
192 KiB
Java
4368 lines
192 KiB
Java
|
/* GENERATED SOURCE. DO NOT MODIFY. */
|
||
|
|
// © 2016 and later: Unicode, Inc. and others.
|
||
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
||
|
|
/*
|
||
|
|
*******************************************************************************
|
||
|
|
* Copyright (C) 1996-2016, International Business Machines Corporation and
|
||
|
|
* others. All Rights Reserved.
|
||
|
|
*******************************************************************************
|
||
|
|
*/
|
||
|
|
|
||
|
|
package android.icu.text;
|
||
|
|
|
||
|
|
import java.io.IOException;
|
||
|
|
import java.io.ObjectInputStream;
|
||
|
|
import java.io.ObjectOutputStream;
|
||
|
|
import java.text.AttributedCharacterIterator;
|
||
|
|
import java.text.AttributedString;
|
||
|
|
import java.text.FieldPosition;
|
||
|
|
import java.text.Format;
|
||
|
|
import java.text.ParsePosition;
|
||
|
|
import java.util.ArrayList;
|
||
|
|
import java.util.Date;
|
||
|
|
import java.util.HashMap;
|
||
|
|
import java.util.List;
|
||
|
|
import java.util.Locale;
|
||
|
|
import java.util.MissingResourceException;
|
||
|
|
import java.util.UUID;
|
||
|
|
|
||
|
|
import android.icu.impl.DateNumberFormat;
|
||
|
|
import android.icu.impl.DayPeriodRules;
|
||
|
|
import android.icu.impl.ICUCache;
|
||
|
|
import android.icu.impl.ICUData;
|
||
|
|
import android.icu.impl.ICUResourceBundle;
|
||
|
|
import android.icu.impl.PatternProps;
|
||
|
|
import android.icu.impl.SimpleCache;
|
||
|
|
import android.icu.impl.SimpleFormatterImpl;
|
||
|
|
import android.icu.lang.UCharacter;
|
||
|
|
import android.icu.text.TimeZoneFormat.Style;
|
||
|
|
import android.icu.text.TimeZoneFormat.TimeType;
|
||
|
|
import android.icu.util.BasicTimeZone;
|
||
|
|
import android.icu.util.BasicTimeZone.LocalOption;
|
||
|
|
import android.icu.util.Calendar;
|
||
|
|
import android.icu.util.HebrewCalendar;
|
||
|
|
import android.icu.util.Output;
|
||
|
|
import android.icu.util.TimeZone;
|
||
|
|
import android.icu.util.TimeZoneTransition;
|
||
|
|
import android.icu.util.ULocale;
|
||
|
|
import android.icu.util.ULocale.Category;
|
||
|
|
import android.icu.util.UResourceBundle;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <strong>[icu enhancement]</strong> ICU's replacement for {@link java.text.SimpleDateFormat}. Methods, fields, and other functionality specific to ICU are labeled '<strong>[icu]</strong>'.
|
||
|
|
*
|
||
|
|
* <p><code>SimpleDateFormat</code> is a concrete class for formatting and
|
||
|
|
* parsing dates in a locale-sensitive manner. It allows for formatting
|
||
|
|
* (date -> text), parsing (text -> date), and normalization.
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* Clients are encouraged to create a date-time formatter using
|
||
|
|
* <code>DateFormat.getDateInstance()</code>, <code>DateFormat.getDateInstance()</code>,
|
||
|
|
* or <code>DateFormat.getDateTimeInstance()</code> rather than
|
||
|
|
* explicitly constructing an instance of <code>SimpleDateFormat</code>. This way, the client
|
||
|
|
* is guaranteed to get an appropriate formatting pattern for whatever locale the
|
||
|
|
* program is running in. If the client needs more control, they should consider using
|
||
|
|
* <code>DateFormat.getInstanceForSkeleton()</code>.
|
||
|
|
* However, if the client needs something more unusual than
|
||
|
|
* the default patterns in the locales, he can construct a <code>SimpleDateFormat</code> directly
|
||
|
|
* and give it an appropriate pattern (or use one of the factory methods on DateFormat
|
||
|
|
* and modify the pattern after the fact with <code>toPattern()</code> and <code>applyPattern()</code>.
|
||
|
|
* For more information on using these methods, see
|
||
|
|
* {@link DateFormat}.
|
||
|
|
*
|
||
|
|
* <p><strong>Date and Time Patterns:</strong></p>
|
||
|
|
*
|
||
|
|
* <p>Date and time formats are specified by <em>date and time pattern</em> strings.
|
||
|
|
* The full syntax for date and time patterns can be found at
|
||
|
|
* <a href="https://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns">https://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns</a>.</p>
|
||
|
|
*
|
||
|
|
* <p>Within date and time pattern strings, all unquoted ASCII letters [A-Za-z] are reserved
|
||
|
|
* as pattern letters representing calendar fields. Some of the most commonly used pattern letters are:</p>
|
||
|
|
* <blockquote>
|
||
|
|
* <table border="1">
|
||
|
|
* <tr>
|
||
|
|
* <th style="text-align: center">Sym.</th>
|
||
|
|
* <th style="text-align: center">No.</th>
|
||
|
|
* <th>Example</th>
|
||
|
|
* <th>Description</th>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">G</td>
|
||
|
|
* <td style="text-align: center">1..3</td>
|
||
|
|
* <td>AD</td>
|
||
|
|
* <td>Era - Replaced with the Era string for the current date. One to three letters for the
|
||
|
|
* abbreviated form, four letters for the long (wide) form, five for the narrow form.</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">y</td>
|
||
|
|
* <td style="text-align: center">1..n</td>
|
||
|
|
* <td>1996</td>
|
||
|
|
* <td>Year. Normally the length specifies the padding, but for two letters it also specifies the maximum
|
||
|
|
* length. Example:<div style="text-align: center">
|
||
|
|
* <center>
|
||
|
|
* <table border="1" cellpadding="2" cellspacing="0">
|
||
|
|
* <tr>
|
||
|
|
* <th>Year</th>
|
||
|
|
* <th style="text-align: right">y</th>
|
||
|
|
* <th style="text-align: right">yy</th>
|
||
|
|
* <th style="text-align: right">yyy</th>
|
||
|
|
* <th style="text-align: right">yyyy</th>
|
||
|
|
* <th style="text-align: right">yyyyy</th>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td>AD 1</td>
|
||
|
|
* <td style="text-align: right">1</td>
|
||
|
|
* <td style="text-align: right">01</td>
|
||
|
|
* <td style="text-align: right">001</td>
|
||
|
|
* <td style="text-align: right">0001</td>
|
||
|
|
* <td style="text-align: right">00001</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td>AD 12</td>
|
||
|
|
* <td style="text-align: right">12</td>
|
||
|
|
* <td style="text-align: right">12</td>
|
||
|
|
* <td style="text-align: right">012</td>
|
||
|
|
* <td style="text-align: right">0012</td>
|
||
|
|
* <td style="text-align: right">00012</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td>AD 123</td>
|
||
|
|
* <td style="text-align: right">123</td>
|
||
|
|
* <td style="text-align: right">23</td>
|
||
|
|
* <td style="text-align: right">123</td>
|
||
|
|
* <td style="text-align: right">0123</td>
|
||
|
|
* <td style="text-align: right">00123</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td>AD 1234</td>
|
||
|
|
* <td style="text-align: right">1234</td>
|
||
|
|
* <td style="text-align: right">34</td>
|
||
|
|
* <td style="text-align: right">1234</td>
|
||
|
|
* <td style="text-align: right">1234</td>
|
||
|
|
* <td style="text-align: right">01234</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td>AD 12345</td>
|
||
|
|
* <td style="text-align: right">12345</td>
|
||
|
|
* <td style="text-align: right">45</td>
|
||
|
|
* <td style="text-align: right">12345</td>
|
||
|
|
* <td style="text-align: right">12345</td>
|
||
|
|
* <td style="text-align: right">12345</td>
|
||
|
|
* </tr>
|
||
|
|
* </table>
|
||
|
|
* </center></div>
|
||
|
|
* </td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td rowspan="3" style="text-align: center">Q</td>
|
||
|
|
* <td style="text-align: center">1..2</td>
|
||
|
|
* <td>02</td>
|
||
|
|
* <td rowspan="3">Quarter - Use one or two for the numerical quarter, three for the abbreviation, or four
|
||
|
|
* for the full (wide) name (five for the narrow name is not yet supported).</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">3</td>
|
||
|
|
* <td>Q2</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">4</td>
|
||
|
|
* <td>2nd quarter</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td rowspan="4" style="text-align: center">M</td>
|
||
|
|
* <td style="text-align: center">1..2</td>
|
||
|
|
* <td>09</td>
|
||
|
|
* <td rowspan="4">Month - Use one or two for the numerical month, three for the abbreviation, four for
|
||
|
|
* the full (wide) name, or five for the narrow name. With two ("MM"), the month number is zero-padded
|
||
|
|
* if necessary (e.g. "08").</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">3</td>
|
||
|
|
* <td>Sep</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">4</td>
|
||
|
|
* <td>September</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">5</td>
|
||
|
|
* <td>S</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">d</td>
|
||
|
|
* <td style="text-align: center">1..2</td>
|
||
|
|
* <td>1</td>
|
||
|
|
* <td>Date - Day of the month. Use "d" to show the minimum number of digits, or "dd" to always show
|
||
|
|
* two digits (zero-padding if necessary, e.g. "08").</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td rowspan="4" style="text-align: center">E</td>
|
||
|
|
* <td style="text-align: center">1..3</td>
|
||
|
|
* <td>Tue</td>
|
||
|
|
* <td rowspan="4">Day of week - Use one through three letters for the short day, four for the full (wide) name,
|
||
|
|
* five for the narrow name, or six for the short name.</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">4</td>
|
||
|
|
* <td>Tuesday</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">5</td>
|
||
|
|
* <td>T</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">6</td>
|
||
|
|
* <td>Tu</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">a</td>
|
||
|
|
* <td style="text-align: center">1</td>
|
||
|
|
* <td>AM</td>
|
||
|
|
* <td>AM or PM</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">h</td>
|
||
|
|
* <td style="text-align: center">1..2</td>
|
||
|
|
* <td>11</td>
|
||
|
|
* <td>Hour [1-12]. When used in skeleton data or in a skeleton passed in an API for flexible data pattern
|
||
|
|
* generation, it should match the 12-hour-cycle format preferred by the locale (h or K); it should not match
|
||
|
|
* a 24-hour-cycle format (H or k). Use hh for zero padding.</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">H</td>
|
||
|
|
* <td style="text-align: center">1..2</td>
|
||
|
|
* <td>13</td>
|
||
|
|
* <td>Hour [0-23]. When used in skeleton data or in a skeleton passed in an API for flexible data pattern
|
||
|
|
* generation, it should match the 24-hour-cycle format preferred by the locale (H or k); it should not match a
|
||
|
|
* 12-hour-cycle format (h or K). Use HH for zero padding.</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">m</td>
|
||
|
|
* <td style="text-align: center">1..2</td>
|
||
|
|
* <td>59</td>
|
||
|
|
* <td>Minute. Use "m" to show the minimum number of digits, or "mm" to always show two digits
|
||
|
|
* (zero-padding if necessary, e.g. "08")..</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">s</td>
|
||
|
|
* <td style="text-align: center">1..2</td>
|
||
|
|
* <td>12</td>
|
||
|
|
* <td>Second. Use "s" to show the minimum number of digits, or "ss" to always show two digits
|
||
|
|
* (zero-padding if necessary, e.g. "08").</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td rowspan="2" style="text-align: center">z</td>
|
||
|
|
* <td style="text-align: center">1..3</td>
|
||
|
|
* <td>PDT</td>
|
||
|
|
* <td>Time zone. The <i>short specific non-location format</i>.
|
||
|
|
* Where that is unavailable, falls back to the <i>short localized GMT format</i> ("O").</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">4</td>
|
||
|
|
* <td>Pacific Daylight Time</td>
|
||
|
|
* <td>The <i>long specific non-location format</i>.
|
||
|
|
* Where that is unavailable, falls back to the <i>long localized GMT format</i> ("OOOO").</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td rowspan="2" style="text-align: center">v</td>
|
||
|
|
* <td style="text-align: center">1</td>
|
||
|
|
* <td>PT</td>
|
||
|
|
* <td>Time zone. The <i>short generic non-location format</i>.
|
||
|
|
* Where that is unavailable, falls back to the <i>generic location format</i> ("VVVV"),
|
||
|
|
* then the <i>short localized GMT format</i> as the final fallback.</td>
|
||
|
|
* </tr>
|
||
|
|
* <tr>
|
||
|
|
* <td style="text-align: center">4</td>
|
||
|
|
* <td>Pacific Time</td>
|
||
|
|
* <td>The <i>long generic non-location format</i>.
|
||
|
|
* Where that is unavailable, falls back to <i>generic location format</i> ("VVVV").
|
||
|
|
* </tr>
|
||
|
|
* </table>
|
||
|
|
*
|
||
|
|
* </blockquote>
|
||
|
|
* <p>
|
||
|
|
* Any characters in the pattern that are not in the ranges of ['a'..'z']
|
||
|
|
* and ['A'..'Z'] will be treated as quoted text. For instance, characters
|
||
|
|
* like ':', '.', ' ', '#' and '@' will appear in the resulting time text
|
||
|
|
* even they are not embraced within single quotes.
|
||
|
|
* <p>
|
||
|
|
* A pattern containing any invalid pattern letter will result in a thrown
|
||
|
|
* exception during formatting or parsing.
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* <strong>Examples Using the US Locale:</strong>
|
||
|
|
* <blockquote>
|
||
|
|
* <pre>
|
||
|
|
* Format Pattern Result
|
||
|
|
* -------------- -------
|
||
|
|
* "yyyy.MM.dd G 'at' HH:mm:ss vvvv" ->> 1996.07.10 AD at 15:08:56 Pacific Time
|
||
|
|
* "EEE, MMM d, ''yy" ->> Wed, July 10, '96
|
||
|
|
* "h:mm a" ->> 12:08 PM
|
||
|
|
* "hh 'o''clock' a, zzzz" ->> 12 o'clock PM, Pacific Daylight Time
|
||
|
|
* "K:mm a, vvv" ->> 0:00 PM, PT
|
||
|
|
* "yyyyy.MMMMM.dd GGG hh:mm aaa" ->> 01996.July.10 AD 12:08 PM
|
||
|
|
* </pre>
|
||
|
|
* </blockquote>
|
||
|
|
* <strong>Code Sample:</strong>
|
||
|
|
* <blockquote>
|
||
|
|
* <pre>
|
||
|
|
* SimpleTimeZone pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, "PST");
|
||
|
|
* pdt.setStartRule(Calendar.APRIL, 1, Calendar.SUNDAY, 2*60*60*1000);
|
||
|
|
* pdt.setEndRule(Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*60*60*1000);
|
||
|
|
* <br>
|
||
|
|
* // Format the current time.
|
||
|
|
* SimpleDateFormat formatter
|
||
|
|
* = new SimpleDateFormat ("yyyy.MM.dd G 'at' hh:mm:ss a zzz");
|
||
|
|
* Date currentTime_1 = new Date();
|
||
|
|
* String dateString = formatter.format(currentTime_1);
|
||
|
|
* <br>
|
||
|
|
* // Parse the previous string back into a Date.
|
||
|
|
* ParsePosition pos = new ParsePosition(0);
|
||
|
|
* Date currentTime_2 = formatter.parse(dateString, pos);
|
||
|
|
* </pre>
|
||
|
|
* </blockquote>
|
||
|
|
* In the example, the time value <code>currentTime_2</code> obtained from
|
||
|
|
* parsing will be equal to <code>currentTime_1</code>. However, they may not be
|
||
|
|
* equal if the am/pm marker 'a' is left out from the format pattern while
|
||
|
|
* the "hour in am/pm" pattern symbol is used. This information loss can
|
||
|
|
* happen when formatting the time in PM.
|
||
|
|
*
|
||
|
|
* <p>When parsing a date string using the abbreviated year pattern ("yy"),
|
||
|
|
* SimpleDateFormat 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 SimpleDateFormat
|
||
|
|
* instance is created. For example, using a pattern of "MM/dd/yy" and a
|
||
|
|
* SimpleDateFormat instance created on Jan 1, 1997, the string
|
||
|
|
* "01/11/12" would be interpreted as Jan 11, 2012 while the string "05/04/64"
|
||
|
|
* would be interpreted as May 4, 1964.
|
||
|
|
* During parsing, only strings consisting of exactly two digits, as defined by
|
||
|
|
* {@link android.icu.lang.UCharacter#isDigit(int)}, will be parsed into the default
|
||
|
|
* century.
|
||
|
|
* Any other numeric string, such as a one digit string, a three or more digit
|
||
|
|
* string, or a two digit string that isn't all digits (for example, "-1"), is
|
||
|
|
* interpreted literally. So "01/02/3" or "01/02/003" are parsed, using the
|
||
|
|
* same pattern, as Jan 2, 3 AD. Likewise, "01/02/-3" is parsed as Jan 2, 4 BC.
|
||
|
|
*
|
||
|
|
* <p>If the year pattern does not have exactly two 'y' characters, the year is
|
||
|
|
* interpreted literally, regardless of the number of digits. So using the
|
||
|
|
* pattern "MM/dd/yyyy", "01/11/12" parses to Jan 11, 12 A.D.
|
||
|
|
*
|
||
|
|
* <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>For time zones that have no names, use strings GMT+hours:minutes or
|
||
|
|
* GMT-hours:minutes.
|
||
|
|
*
|
||
|
|
* <p>The calendar defines what is the first day of the week, the first week
|
||
|
|
* of the year, whether hours are zero based or not (0 vs 12 or 24), and the
|
||
|
|
* time zone. There is one common decimal format to handle all the numbers;
|
||
|
|
* the digit count is handled programmatically according to the pattern.
|
||
|
|
*
|
||
|
|
* <h3>Synchronization</h3>
|
||
|
|
*
|
||
|
|
* Date formats are not synchronized. It is recommended to create separate
|
||
|
|
* format instances for each thread. If multiple threads access a format
|
||
|
|
* concurrently, it must be synchronized externally.
|
||
|
|
*
|
||
|
|
* @see android.icu.util.Calendar
|
||
|
|
* @see android.icu.util.GregorianCalendar
|
||
|
|
* @see android.icu.util.TimeZone
|
||
|
|
* @see DateFormat
|
||
|
|
* @see DateFormatSymbols
|
||
|
|
* @see DecimalFormat
|
||
|
|
* @see TimeZoneFormat
|
||
|
|
* @author Mark Davis, Chen-Lieh Huang, Alan Liu
|
||
|
|
*/
|
||
|
|
public class SimpleDateFormat extends DateFormat {
|
||
|
|
|
||
|
|
// the official serial version ID which says cryptically
|
||
|
|
// which version we're compatible with
|
||
|
|
private static final long serialVersionUID = 4774881970558875024L;
|
||
|
|
|
||
|
|
// the internal serial version which says which version was written
|
||
|
|
// - 0 (default) for version up to JDK 1.1.3
|
||
|
|
// - 1 for version from JDK 1.1.4, which includes a new field
|
||
|
|
// - 2 we write additional int for capitalizationSetting
|
||
|
|
static final int currentSerialVersion = 2;
|
||
|
|
|
||
|
|
static boolean DelayedHebrewMonthCheck = false;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* From calendar field to its level.
|
||
|
|
* Used to order calendar field.
|
||
|
|
* For example, calendar fields can be defined in the following order:
|
||
|
|
* year > month > date > am-pm > hour > minute
|
||
|
|
* YEAR --> 10, MONTH -->20, DATE --> 30;
|
||
|
|
* AM_PM -->40, HOUR --> 50, MINUTE -->60
|
||
|
|
*/
|
||
|
|
private static final int[] CALENDAR_FIELD_TO_LEVEL =
|
||
|
|
{
|
||
|
|
/*GyM*/ 0, 10, 20,
|
||
|
|
/*wW*/ 20, 30,
|
||
|
|
/*dDEF*/ 30, 20, 30, 30,
|
||
|
|
/*ahHm*/ 40, 50, 50, 60,
|
||
|
|
/*sS*/ 70, 80,
|
||
|
|
/*z?Y*/ 0, 0, 10,
|
||
|
|
/*eug*/ 30, 10, 0,
|
||
|
|
/*A?*/ 40, 0, 0
|
||
|
|
};
|
||
|
|
|
||
|
|
/*
|
||
|
|
* From calendar field letter to its level.
|
||
|
|
* Used to order calendar field.
|
||
|
|
* For example, calendar fields can be defined in the following order:
|
||
|
|
* year > month > date > am-pm > hour > minute
|
||
|
|
* 'y' --> 10, 'M' -->20, 'd' --> 30; 'a' -->40, 'h' --> 50, 'm' -->60
|
||
|
|
*/
|
||
|
|
private static final int[] PATTERN_CHAR_TO_LEVEL =
|
||
|
|
{
|
||
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||
|
|
//
|
||
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||
|
|
// ! " # $ % & ' ( ) * + , - . /
|
||
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||
|
|
// 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
|
||
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||
|
|
// @ A B C D E F G H I J K L M N O
|
||
|
|
-1, 40, -1, -1, 20, 30, 30, 0, 50, -1, -1, 50, 20, 20, -1, 0,
|
||
|
|
// P Q R S T U V W X Y Z [ \ ] ^ _
|
||
|
|
-1, 20, -1, 80, -1, 10, 0, 30, 0, 10, 0, -1, -1, -1, -1, -1,
|
||
|
|
// ` a b c d e f g h i j k l m n o
|
||
|
|
-1, 40, -1, 30, 30, 30, -1, 0, 50, -1, -1, 50, -1, 60, -1, -1,
|
||
|
|
// p q r s t u v w x y z { | } ~
|
||
|
|
-1, 20, 10, 70, -1, 10, 0, 20, 0, 10, 0, -1, -1, -1, -1, -1,
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Map calendar field letter into calendar field level.
|
||
|
|
*/
|
||
|
|
private static int getLevelFromChar(char ch) {
|
||
|
|
return ch < PATTERN_CHAR_TO_LEVEL.length ? PATTERN_CHAR_TO_LEVEL[ch & 0xff] : -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static final boolean[] PATTERN_CHAR_IS_SYNTAX =
|
||
|
|
{
|
||
|
|
//
|
||
|
|
false, false, false, false, false, false, false, false,
|
||
|
|
//
|
||
|
|
false, false, false, false, false, false, false, false,
|
||
|
|
//
|
||
|
|
false, false, false, false, false, false, false, false,
|
||
|
|
//
|
||
|
|
false, false, false, false, false, false, false, false,
|
||
|
|
// ! " # $ % & '
|
||
|
|
false, false, false, false, false, false, false, false,
|
||
|
|
// ( ) * + , - . /
|
||
|
|
false, false, false, false, false, false, false, false,
|
||
|
|
// 0 1 2 3 4 5 6 7
|
||
|
|
false, false, false, false, false, false, false, false,
|
||
|
|
// 8 9 : ; < = > ?
|
||
|
|
false, false, false, false, false, false, false, false,
|
||
|
|
// @ A B C D E F G
|
||
|
|
false, true, true, true, true, true, true, true,
|
||
|
|
// H I J K L M N O
|
||
|
|
true, true, true, true, true, true, true, true,
|
||
|
|
// P Q R S T U V W
|
||
|
|
true, true, true, true, true, true, true, true,
|
||
|
|
// X Y Z [ \ ] ^ _
|
||
|
|
true, true, true, false, false, false, false, false,
|
||
|
|
// ` a b c d e f g
|
||
|
|
false, true, true, true, true, true, true, true,
|
||
|
|
// h i j k l m n o
|
||
|
|
true, true, true, true, true, true, true, true,
|
||
|
|
// p q r s t u v w
|
||
|
|
true, true, true, true, true, true, true, true,
|
||
|
|
// x y z { | } ~
|
||
|
|
true, true, true, false, false, false, false, false,
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Tell if a character can be used to define a field in a format string.
|
||
|
|
*/
|
||
|
|
private static boolean isSyntaxChar(char ch) {
|
||
|
|
return ch < PATTERN_CHAR_IS_SYNTAX.length ? PATTERN_CHAR_IS_SYNTAX[ch & 0xff] : false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// When calendar uses hebr numbering (i.e. he@calendar=hebrew),
|
||
|
|
// offset the years within the current millenium down to 1-999
|
||
|
|
private static final int HEBREW_CAL_CUR_MILLENIUM_START_YEAR = 5000;
|
||
|
|
private static final int HEBREW_CAL_CUR_MILLENIUM_END_YEAR = 6000;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The version of the serialized data on the stream. Possible values:
|
||
|
|
* <ul>
|
||
|
|
* <li><b>0</b> or not present on stream: JDK 1.1.3. This version
|
||
|
|
* has no <code>defaultCenturyStart</code> on stream.
|
||
|
|
* <li><b>1</b> JDK 1.1.4 or later. This version adds
|
||
|
|
* <code>defaultCenturyStart</code>.
|
||
|
|
* <li><b>2</b> This version writes an additional int for
|
||
|
|
* <code>capitalizationSetting</code>.
|
||
|
|
* </ul>
|
||
|
|
* When streaming out this class, the most recent format
|
||
|
|
* and the highest allowable <code>serialVersionOnStream</code>
|
||
|
|
* is written.
|
||
|
|
* @serial
|
||
|
|
*/
|
||
|
|
private int serialVersionOnStream = currentSerialVersion;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The pattern string of this formatter. This is always a non-localized
|
||
|
|
* pattern. May not be null. See class documentation for details.
|
||
|
|
* @serial
|
||
|
|
*/
|
||
|
|
private String pattern;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The override string of this formatter. Used to override the
|
||
|
|
* numbering system for one or more fields.
|
||
|
|
* @serial
|
||
|
|
*/
|
||
|
|
private String override;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The hash map used for number format overrides.
|
||
|
|
* @serial
|
||
|
|
*/
|
||
|
|
private HashMap<String, NumberFormat> numberFormatters;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The hash map used for number format overrides.
|
||
|
|
* @serial
|
||
|
|
*/
|
||
|
|
private HashMap<Character, String> overrideMap;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The symbols used by this formatter for week names, month names,
|
||
|
|
* etc. May not be null.
|
||
|
|
* @serial
|
||
|
|
* @see DateFormatSymbols
|
||
|
|
*/
|
||
|
|
private DateFormatSymbols formatData;
|
||
|
|
|
||
|
|
private transient ULocale locale;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* We map dates with two-digit years into the century starting at
|
||
|
|
* <code>defaultCenturyStart</code>, which may be any date. May
|
||
|
|
* not be null.
|
||
|
|
* @serial
|
||
|
|
*/
|
||
|
|
private Date defaultCenturyStart;
|
||
|
|
|
||
|
|
private transient int defaultCenturyStartYear;
|
||
|
|
|
||
|
|
// defaultCenturyBase is set when an instance is created
|
||
|
|
// and may be used for calculating defaultCenturyStart when needed.
|
||
|
|
private transient long defaultCenturyBase;
|
||
|
|
|
||
|
|
private static final int millisPerHour = 60 * 60 * 1000;
|
||
|
|
|
||
|
|
// When possessing ISO format, the ERA may be ommitted is the
|
||
|
|
// year specifier is a negative number.
|
||
|
|
private static final int ISOSpecialEra = -32000;
|
||
|
|
|
||
|
|
// This prefix is designed to NEVER MATCH real text, in order to
|
||
|
|
// suppress the parsing of negative numbers. Adjust as needed (if
|
||
|
|
// this becomes valid Unicode).
|
||
|
|
private static final String SUPPRESS_NEGATIVE_PREFIX = "\uAB00";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* If true, this object supports fast formatting using the
|
||
|
|
* subFormat variant that takes a StringBuffer.
|
||
|
|
*/
|
||
|
|
private transient boolean useFastFormat;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* The time zone sub-formatter, introduced in ICU 4.8
|
||
|
|
*/
|
||
|
|
private volatile TimeZoneFormat tzFormat;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* BreakIterator to use for capitalization (will be cloned for actual use)
|
||
|
|
*/
|
||
|
|
private transient BreakIterator capitalizationBrkIter = null;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* DateFormat pattern contains the minute field.
|
||
|
|
*/
|
||
|
|
private transient boolean hasMinute;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* DateFormat pattern contains the second field.
|
||
|
|
*/
|
||
|
|
private transient boolean hasSecond;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* DateFormat pattern contains the Han year character \u5E74=年, => non-numeric E Asian format.
|
||
|
|
*/
|
||
|
|
private transient boolean hasHanYearChar;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Capitalization setting, introduced in ICU 50
|
||
|
|
* Special serialization, see writeObject & readObject below
|
||
|
|
*
|
||
|
|
* Hoisted to DateFormat in ICU 53, get value with
|
||
|
|
* getContext(DisplayContext.Type.CAPITALIZATION)
|
||
|
|
*/
|
||
|
|
// private transient DisplayContext capitalizationSetting;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Old defaultCapitalizationContext field
|
||
|
|
* from ICU 49.1:
|
||
|
|
*/
|
||
|
|
//private ContextValue defaultCapitalizationContext;
|
||
|
|
/**
|
||
|
|
* Old ContextValue enum, preserved only to avoid
|
||
|
|
* deserialization errs from ICU 49.1.
|
||
|
|
*/
|
||
|
|
@SuppressWarnings("unused")
|
||
|
|
private enum ContextValue {
|
||
|
|
UNKNOWN,
|
||
|
|
CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE,
|
||
|
|
CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE,
|
||
|
|
CAPITALIZATION_FOR_UI_LIST_OR_MENU,
|
||
|
|
CAPITALIZATION_FOR_STANDALONE
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Constructs a SimpleDateFormat using the default pattern for the default <code>FORMAT</code>
|
||
|
|
* locale. <b>Note:</b> Not all locales support SimpleDateFormat; for full
|
||
|
|
* generality, use the factory methods in the DateFormat class.
|
||
|
|
*
|
||
|
|
* @see DateFormat
|
||
|
|
* @see Category#FORMAT
|
||
|
|
*/
|
||
|
|
public SimpleDateFormat() {
|
||
|
|
this(getDefaultPattern(), null, null, null, null, true, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Constructs a SimpleDateFormat using the given pattern in the default <code>FORMAT</code>
|
||
|
|
* locale. <b>Note:</b> Not all locales support SimpleDateFormat; for full
|
||
|
|
* generality, use the factory methods in the DateFormat class.
|
||
|
|
* @see Category#FORMAT
|
||
|
|
*/
|
||
|
|
public SimpleDateFormat(String pattern)
|
||
|
|
{
|
||
|
|
this(pattern, null, null, null, null, true, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Constructs a SimpleDateFormat using the given pattern and locale.
|
||
|
|
* <b>Note:</b> Not all locales support SimpleDateFormat; for full
|
||
|
|
* generality, use the factory methods in the DateFormat class.
|
||
|
|
*/
|
||
|
|
public SimpleDateFormat(String pattern, Locale loc)
|
||
|
|
{
|
||
|
|
this(pattern, null, null, null, ULocale.forLocale(loc), true, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Constructs a SimpleDateFormat using the given pattern and locale.
|
||
|
|
* <b>Note:</b> Not all locales support SimpleDateFormat; for full
|
||
|
|
* generality, use the factory methods in the DateFormat class.
|
||
|
|
*/
|
||
|
|
public SimpleDateFormat(String pattern, ULocale loc)
|
||
|
|
{
|
||
|
|
this(pattern, null, null, null, loc, true, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Constructs a SimpleDateFormat using the given pattern , override and locale.
|
||
|
|
* @param pattern The pattern to be used
|
||
|
|
* @param override The override string. A numbering system override string can take one of the following forms:
|
||
|
|
* 1). If just a numbering system name is specified, it applies to all numeric fields in the date format pattern.
|
||
|
|
* 2). To specify an alternate numbering system on a field by field basis, use the field letters from the pattern
|
||
|
|
* followed by an = sign, followed by the numbering system name. For example, to specify that just the year
|
||
|
|
* be formatted using Hebrew digits, use the override "y=hebr". Multiple overrides can be specified in a single
|
||
|
|
* string by separating them with a semi-colon. For example, the override string "m=thai;y=deva" would format using
|
||
|
|
* Thai digits for the month and Devanagari digits for the year.
|
||
|
|
* @param loc The locale to be used
|
||
|
|
*/
|
||
|
|
public SimpleDateFormat(String pattern, String override, ULocale loc)
|
||
|
|
{
|
||
|
|
this(pattern, null, null, null, loc, false,override);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Constructs a SimpleDateFormat using the given pattern and
|
||
|
|
* locale-specific symbol data.
|
||
|
|
* Warning: uses default <code>FORMAT</code> locale for digits!
|
||
|
|
*/
|
||
|
|
public SimpleDateFormat(String pattern, DateFormatSymbols formatData)
|
||
|
|
{
|
||
|
|
this(pattern, (DateFormatSymbols)formatData.clone(), null, null, null, true, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @deprecated This API is ICU internal only.
|
||
|
|
* @hide original deprecated declaration
|
||
|
|
* @hide draft / provisional / internal are hidden on Android
|
||
|
|
*/
|
||
|
|
@Deprecated
|
||
|
|
public SimpleDateFormat(String pattern, DateFormatSymbols formatData, ULocale loc)
|
||
|
|
{
|
||
|
|
this(pattern, (DateFormatSymbols)formatData.clone(), null, null, loc, true,null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Package-private constructor that allows a subclass to specify
|
||
|
|
* whether it supports fast formatting.
|
||
|
|
*
|
||
|
|
* TODO make this API public.
|
||
|
|
*/
|
||
|
|
SimpleDateFormat(String pattern, DateFormatSymbols formatData, Calendar calendar, ULocale locale,
|
||
|
|
boolean useFastFormat, String override) {
|
||
|
|
this(pattern, (DateFormatSymbols)formatData.clone(), (Calendar)calendar.clone(), null, locale, useFastFormat,override);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* The constructor called from all other SimpleDateFormat constructors
|
||
|
|
*/
|
||
|
|
private SimpleDateFormat(String pattern, DateFormatSymbols formatData, Calendar calendar,
|
||
|
|
NumberFormat numberFormat, ULocale locale, boolean useFastFormat,String override) {
|
||
|
|
this.pattern = pattern;
|
||
|
|
this.formatData = formatData;
|
||
|
|
this.calendar = calendar;
|
||
|
|
this.numberFormat = numberFormat;
|
||
|
|
this.locale = locale; // time zone formatting
|
||
|
|
this.useFastFormat = useFastFormat;
|
||
|
|
this.override = override;
|
||
|
|
initialize();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates an instance of SimpleDateFormat for the given format configuration
|
||
|
|
* @param formatConfig the format configuration
|
||
|
|
* @return A SimpleDateFormat instance
|
||
|
|
* @deprecated This API is ICU internal only.
|
||
|
|
* @hide original deprecated declaration
|
||
|
|
* @hide draft / provisional / internal are hidden on Android
|
||
|
|
*/
|
||
|
|
@Deprecated
|
||
|
|
public static SimpleDateFormat getInstance(Calendar.FormatConfiguration formatConfig) {
|
||
|
|
|
||
|
|
String ostr = formatConfig.getOverrideString();
|
||
|
|
boolean useFast = ( ostr != null && ostr.length() > 0 );
|
||
|
|
|
||
|
|
return new SimpleDateFormat(formatConfig.getPatternString(),
|
||
|
|
formatConfig.getDateFormatSymbols(),
|
||
|
|
formatConfig.getCalendar(),
|
||
|
|
null,
|
||
|
|
formatConfig.getLocale(),
|
||
|
|
useFast,
|
||
|
|
formatConfig.getOverrideString());
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Initialized fields
|
||
|
|
*/
|
||
|
|
private void initialize() {
|
||
|
|
if (locale == null) {
|
||
|
|
locale = ULocale.getDefault(Category.FORMAT);
|
||
|
|
}
|
||
|
|
if (formatData == null) {
|
||
|
|
formatData = new DateFormatSymbols(locale);
|
||
|
|
}
|
||
|
|
if (calendar == null) {
|
||
|
|
calendar = Calendar.getInstance(locale);
|
||
|
|
}
|
||
|
|
if (numberFormat == null) {
|
||
|
|
NumberingSystem ns = NumberingSystem.getInstance(locale);
|
||
|
|
String digitString = ns.getDescription();
|
||
|
|
// DateNumberFormat does not support non-BMP digits at this moment.
|
||
|
|
if (ns.isAlgorithmic() || digitString.length() != 10) {
|
||
|
|
numberFormat = NumberFormat.getInstance(locale);
|
||
|
|
} else {
|
||
|
|
String nsName = ns.getName();
|
||
|
|
// Use a NumberFormat optimized for date formatting
|
||
|
|
numberFormat = new DateNumberFormat(locale, digitString, nsName);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (numberFormat instanceof DecimalFormat) {
|
||
|
|
fixNumberFormatForDates(numberFormat);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Note: deferring calendar calculation until when we really need it.
|
||
|
|
// Instead, we just record time of construction for backward compatibility.
|
||
|
|
defaultCenturyBase = System.currentTimeMillis();
|
||
|
|
|
||
|
|
setLocale(calendar.getLocale(ULocale.VALID_LOCALE ), calendar.getLocale(ULocale.ACTUAL_LOCALE));
|
||
|
|
initLocalZeroPaddingNumberFormat();
|
||
|
|
|
||
|
|
parsePattern(); // Need this before initNumberFormatters(), to set hasHanYearChar
|
||
|
|
|
||
|
|
// Simple-minded hack to force Gannen year numbering for ja@calendar=japanese
|
||
|
|
// if format is non-numeric (includes 年) and overrides are not already specified.
|
||
|
|
// Now this does get updated if applyPattern subsequently changes the pattern type.
|
||
|
|
if (override == null && hasHanYearChar &&
|
||
|
|
calendar != null && calendar.getType().equals("japanese") &&
|
||
|
|
locale != null && locale.getLanguage().equals("ja")) {
|
||
|
|
override = "y=jpanyear";
|
||
|
|
}
|
||
|
|
|
||
|
|
if (override != null) {
|
||
|
|
initNumberFormatters(locale);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Private method lazily instantiate the TimeZoneFormat field
|
||
|
|
* @param bForceUpdate when true, check if tzFormat is synchronized with
|
||
|
|
* the current numberFormat and update its digits if necessary. When false,
|
||
|
|
* this check is skipped.
|
||
|
|
*/
|
||
|
|
private synchronized void initializeTimeZoneFormat(boolean bForceUpdate) {
|
||
|
|
if (bForceUpdate || tzFormat == null) {
|
||
|
|
tzFormat = TimeZoneFormat.getInstance(locale);
|
||
|
|
|
||
|
|
String digits = null;
|
||
|
|
if (numberFormat instanceof DecimalFormat) {
|
||
|
|
DecimalFormatSymbols decsym = ((DecimalFormat) numberFormat).getDecimalFormatSymbols();
|
||
|
|
String[] strDigits = decsym.getDigitStringsLocal();
|
||
|
|
// Note: TimeZoneFormat#setGMTOffsetDigits() does not support string array,
|
||
|
|
// so we need to concatenate digits to make a single string.
|
||
|
|
StringBuilder digitsBuf = new StringBuilder();
|
||
|
|
for (String digit : strDigits) {
|
||
|
|
digitsBuf.append(digit);
|
||
|
|
}
|
||
|
|
digits = digitsBuf.toString();
|
||
|
|
} else if (numberFormat instanceof DateNumberFormat) {
|
||
|
|
digits = new String(((DateNumberFormat)numberFormat).getDigits());
|
||
|
|
}
|
||
|
|
|
||
|
|
if (digits != null) {
|
||
|
|
if (!tzFormat.getGMTOffsetDigits().equals(digits)) {
|
||
|
|
if (tzFormat.isFrozen()) {
|
||
|
|
tzFormat = tzFormat.cloneAsThawed();
|
||
|
|
}
|
||
|
|
tzFormat.setGMTOffsetDigits(digits);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Private method, returns non-null TimeZoneFormat.
|
||
|
|
* @return the TimeZoneFormat used by this formatter.
|
||
|
|
*/
|
||
|
|
private TimeZoneFormat tzFormat() {
|
||
|
|
if (tzFormat == null) {
|
||
|
|
initializeTimeZoneFormat(false);
|
||
|
|
}
|
||
|
|
return tzFormat;
|
||
|
|
}
|
||
|
|
|
||
|
|
// privates for the default pattern
|
||
|
|
private static ULocale cachedDefaultLocale = null;
|
||
|
|
private static String cachedDefaultPattern = null;
|
||
|
|
private static final String FALLBACKPATTERN = "yy/MM/dd HH:mm";
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Returns the default date and time pattern (SHORT) for the default locale.
|
||
|
|
* This method is only used by the default SimpleDateFormat constructor.
|
||
|
|
*/
|
||
|
|
private static synchronized String getDefaultPattern() {
|
||
|
|
ULocale defaultLocale = ULocale.getDefault(Category.FORMAT);
|
||
|
|
if (!defaultLocale.equals(cachedDefaultLocale)) {
|
||
|
|
cachedDefaultLocale = defaultLocale;
|
||
|
|
Calendar cal = Calendar.getInstance(cachedDefaultLocale);
|
||
|
|
|
||
|
|
try {
|
||
|
|
// Load the calendar data directly.
|
||
|
|
ICUResourceBundle rb = (ICUResourceBundle) UResourceBundle.getBundleInstance(
|
||
|
|
ICUData.ICU_BASE_NAME, cachedDefaultLocale);
|
||
|
|
String resourcePath = "calendar/" + cal.getType() + "/DateTimePatterns";
|
||
|
|
ICUResourceBundle patternsRb= rb.findWithFallback(resourcePath);
|
||
|
|
|
||
|
|
if (patternsRb == null) {
|
||
|
|
patternsRb = rb.findWithFallback("calendar/gregorian/DateTimePatterns");
|
||
|
|
}
|
||
|
|
if (patternsRb == null || patternsRb.getSize() < 9) {
|
||
|
|
cachedDefaultPattern = FALLBACKPATTERN;
|
||
|
|
} else {
|
||
|
|
String basePattern = Calendar.getDateAtTimePattern(cal, cachedDefaultLocale, SHORT);
|
||
|
|
|
||
|
|
cachedDefaultPattern = SimpleFormatterImpl.formatRawPattern(
|
||
|
|
basePattern, 2, 2,
|
||
|
|
patternsRb.getString(SHORT), patternsRb.getString(SHORT + 4));
|
||
|
|
}
|
||
|
|
} catch (MissingResourceException e) {
|
||
|
|
cachedDefaultPattern = FALLBACKPATTERN;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return cachedDefaultPattern;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Define one-century window into which to disambiguate dates using
|
||
|
|
* two-digit years.
|
||
|
|
*/
|
||
|
|
private void parseAmbiguousDatesAsAfter(Date startDate) {
|
||
|
|
defaultCenturyStart = startDate;
|
||
|
|
calendar.setTime(startDate);
|
||
|
|
defaultCenturyStartYear = calendar.get(Calendar.YEAR);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Initialize defaultCenturyStart and defaultCenturyStartYear by base time.
|
||
|
|
* The default start time is 80 years before the creation time of this object.
|
||
|
|
*/
|
||
|
|
private void initializeDefaultCenturyStart(long baseTime) {
|
||
|
|
defaultCenturyBase = baseTime;
|
||
|
|
// clone to avoid messing up date stored in calendar object
|
||
|
|
// when this method is called while parsing
|
||
|
|
Calendar tmpCal = (Calendar)calendar.clone();
|
||
|
|
tmpCal.setTimeInMillis(baseTime);
|
||
|
|
tmpCal.add(Calendar.YEAR, -80);
|
||
|
|
defaultCenturyStart = tmpCal.getTime();
|
||
|
|
defaultCenturyStartYear = tmpCal.get(Calendar.YEAR);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Gets the default century start date for this object */
|
||
|
|
private Date getDefaultCenturyStart() {
|
||
|
|
if (defaultCenturyStart == null) {
|
||
|
|
// not yet initialized
|
||
|
|
initializeDefaultCenturyStart(defaultCenturyBase);
|
||
|
|
}
|
||
|
|
return defaultCenturyStart;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Gets the default century start year for this object */
|
||
|
|
private int getDefaultCenturyStartYear() {
|
||
|
|
if (defaultCenturyStart == null) {
|
||
|
|
// not yet initialized
|
||
|
|
initializeDefaultCenturyStart(defaultCenturyBase);
|
||
|
|
}
|
||
|
|
return defaultCenturyStartYear;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets the 100-year period 2-digit years will be interpreted as being in
|
||
|
|
* to begin on the date the user specifies.
|
||
|
|
* @param startDate During parsing, two digit years will be placed in the range
|
||
|
|
* <code>startDate</code> to <code>startDate + 100 years</code>.
|
||
|
|
*/
|
||
|
|
public void set2DigitYearStart(Date startDate) {
|
||
|
|
parseAmbiguousDatesAsAfter(startDate);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the beginning date of the 100-year period 2-digit years are interpreted
|
||
|
|
* as being within.
|
||
|
|
* @return the start of the 100-year period into which two digit years are
|
||
|
|
* parsed
|
||
|
|
*/
|
||
|
|
public Date get2DigitYearStart() {
|
||
|
|
return getDefaultCenturyStart();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <strong>[icu]</strong> Set a particular DisplayContext value in the formatter,
|
||
|
|
* such as CAPITALIZATION_FOR_STANDALONE. Note: For getContext, see
|
||
|
|
* DateFormat.
|
||
|
|
*
|
||
|
|
* @param context The DisplayContext value to set.
|
||
|
|
*/
|
||
|
|
// Here we override the DateFormat implementation in order to lazily initialize relevant items
|
||
|
|
@Override
|
||
|
|
public void setContext(DisplayContext context) {
|
||
|
|
super.setContext(context);
|
||
|
|
if (capitalizationBrkIter == null && (context==DisplayContext.CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE ||
|
||
|
|
context==DisplayContext.CAPITALIZATION_FOR_UI_LIST_OR_MENU ||
|
||
|
|
context==DisplayContext.CAPITALIZATION_FOR_STANDALONE)) {
|
||
|
|
capitalizationBrkIter = BreakIterator.getSentenceInstance(locale);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Formats a date or time, which is the standard millis
|
||
|
|
* since January 1, 1970, 00:00:00 GMT.
|
||
|
|
* <p>Example: using the US locale:
|
||
|
|
* "yyyy.MM.dd G 'at' HH:mm:ss zzz" ->> 1996.07.10 AD at 15:08:56 PDT
|
||
|
|
* @param cal the calendar whose date-time value is to be formatted into a date-time string
|
||
|
|
* @param toAppendTo where the new date-time text is to be appended
|
||
|
|
* @param pos the formatting position. On input: an alignment field,
|
||
|
|
* if desired. On output: the offsets of the alignment field.
|
||
|
|
* @return the formatted date-time string.
|
||
|
|
* @see DateFormat
|
||
|
|
*/
|
||
|
|
@Override
|
||
|
|
public StringBuffer format(Calendar cal, StringBuffer toAppendTo,
|
||
|
|
FieldPosition pos) {
|
||
|
|
return format(cal, toAppendTo, pos, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Internal formatting method that accepts an attributes list. */
|
||
|
|
StringBuffer format(Calendar cal, StringBuffer toAppendTo, FieldPosition pos, List<FieldPosition> attributes) {
|
||
|
|
TimeZone backupTZ = null;
|
||
|
|
if (cal != calendar && !cal.getType().equals(calendar.getType())) {
|
||
|
|
// Different calendar type
|
||
|
|
// We use the time and time zone from the input calendar, but
|
||
|
|
// do not use the input calendar for field calculation.
|
||
|
|
calendar.setTimeInMillis(cal.getTimeInMillis());
|
||
|
|
backupTZ = calendar.getTimeZone();
|
||
|
|
calendar.setTimeZone(cal.getTimeZone());
|
||
|
|
cal = calendar;
|
||
|
|
}
|
||
|
|
StringBuffer result = format(cal, getContext(DisplayContext.Type.CAPITALIZATION), toAppendTo, pos, attributes);
|
||
|
|
if (backupTZ != null) {
|
||
|
|
// Restore the original time zone
|
||
|
|
calendar.setTimeZone(backupTZ);
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
// The actual method to format date. If List attributes is not null,
|
||
|
|
// then attribute information will be recorded.
|
||
|
|
private StringBuffer format(Calendar cal, DisplayContext capitalizationContext,
|
||
|
|
StringBuffer toAppendTo, FieldPosition pos, List<FieldPosition> attributes) {
|
||
|
|
// Initialize
|
||
|
|
pos.setBeginIndex(0);
|
||
|
|
pos.setEndIndex(0);
|
||
|
|
|
||
|
|
// Careful: For best performance, minimize the number of calls
|
||
|
|
// to StringBuffer.append() by consolidating appends when
|
||
|
|
// possible.
|
||
|
|
|
||
|
|
Object[] items = getPatternItems();
|
||
|
|
for (int i = 0; i < items.length; i++) {
|
||
|
|
if (items[i] instanceof String) {
|
||
|
|
toAppendTo.append((String)items[i]);
|
||
|
|
} else {
|
||
|
|
PatternItem item = (PatternItem)items[i];
|
||
|
|
int start = 0;
|
||
|
|
if (attributes != null) {
|
||
|
|
// Save the current length
|
||
|
|
start = toAppendTo.length();
|
||
|
|
}
|
||
|
|
if (useFastFormat) {
|
||
|
|
subFormat(toAppendTo, item.type, item.length, toAppendTo.length(),
|
||
|
|
i, capitalizationContext, pos, item.type, cal);
|
||
|
|
} else {
|
||
|
|
toAppendTo.append(subFormat(item.type, item.length, toAppendTo.length(),
|
||
|
|
i, capitalizationContext, pos, item.type, cal));
|
||
|
|
}
|
||
|
|
if (attributes != null) {
|
||
|
|
// Check the sub format length
|
||
|
|
int end = toAppendTo.length();
|
||
|
|
if (end - start > 0) {
|
||
|
|
// Append the attribute to the list
|
||
|
|
DateFormat.Field attr = patternCharToDateFormatField(item.type);
|
||
|
|
FieldPosition fp = new FieldPosition(attr);
|
||
|
|
fp.setBeginIndex(start);
|
||
|
|
fp.setEndIndex(end);
|
||
|
|
attributes.add(fp);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return toAppendTo;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
// Map pattern character to index
|
||
|
|
private static final int[] PATTERN_CHAR_TO_INDEX =
|
||
|
|
{
|
||
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||
|
|
//
|
||
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||
|
|
// ! " # $ % & ' ( ) * + , - . /
|
||
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||
|
|
// 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
|
||
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||
|
|
// @ A B C D E F G H I J K L M N O
|
||
|
|
-1, 22, 36, -1, 10, 9, 11, 0, 5, -1, -1, 16, 26, 2, -1, 31,
|
||
|
|
// P Q R S T U V W X Y Z [ \ ] ^ _
|
||
|
|
-1, 27, -1, 8, -1, 30, 29, 13, 32, 18, 23, -1, -1, -1, -1, -1,
|
||
|
|
// ` a b c d e f g h i j k l m n o
|
||
|
|
-1, 14, 35, 25, 3, 19, -1, 21, 15, -1, -1, 4, -1, 6, -1, -1,
|
||
|
|
// p q r s t u v w x y z { | } ~
|
||
|
|
-1, 28, 34, 7, -1, 20, 24, 12, 33, 1, 17, -1, -1, -1, -1, -1,
|
||
|
|
};
|
||
|
|
|
||
|
|
private static int getIndexFromChar(char ch) {
|
||
|
|
return ch < PATTERN_CHAR_TO_INDEX.length ? PATTERN_CHAR_TO_INDEX[ch & 0xff] : -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Map pattern character index to Calendar field number
|
||
|
|
private static final int[] PATTERN_INDEX_TO_CALENDAR_FIELD =
|
||
|
|
{
|
||
|
|
/*GyM*/ Calendar.ERA, Calendar.YEAR, Calendar.MONTH,
|
||
|
|
/*dkH*/ Calendar.DATE, Calendar.HOUR_OF_DAY, Calendar.HOUR_OF_DAY,
|
||
|
|
/*msS*/ Calendar.MINUTE, Calendar.SECOND, Calendar.MILLISECOND,
|
||
|
|
/*EDF*/ Calendar.DAY_OF_WEEK, Calendar.DAY_OF_YEAR, Calendar.DAY_OF_WEEK_IN_MONTH,
|
||
|
|
/*wWa*/ Calendar.WEEK_OF_YEAR, Calendar.WEEK_OF_MONTH, Calendar.AM_PM,
|
||
|
|
/*hKz*/ Calendar.HOUR, Calendar.HOUR, Calendar.ZONE_OFFSET,
|
||
|
|
/*Yeu*/ Calendar.YEAR_WOY, Calendar.DOW_LOCAL, Calendar.EXTENDED_YEAR,
|
||
|
|
/*gAZ*/ Calendar.JULIAN_DAY, Calendar.MILLISECONDS_IN_DAY, Calendar.ZONE_OFFSET /* also DST_OFFSET */,
|
||
|
|
/*v*/ Calendar.ZONE_OFFSET /* also DST_OFFSET */,
|
||
|
|
/*c*/ Calendar.DOW_LOCAL,
|
||
|
|
/*L*/ Calendar.MONTH,
|
||
|
|
/*Qq*/ Calendar.MONTH, Calendar.MONTH,
|
||
|
|
/*V*/ Calendar.ZONE_OFFSET /* also DST_OFFSET */,
|
||
|
|
/*U*/ Calendar.YEAR,
|
||
|
|
/*O*/ Calendar.ZONE_OFFSET /* also DST_OFFSET */,
|
||
|
|
/*Xx*/ Calendar.ZONE_OFFSET /* also DST_OFFSET */, Calendar.ZONE_OFFSET /* also DST_OFFSET */,
|
||
|
|
/*r*/ Calendar.EXTENDED_YEAR /* not an exact match */,
|
||
|
|
/*bB*/ -1, -1 /* am/pm/midnight/noon and flexible day period fields; no mapping to calendar fields */
|
||
|
|
/*:*/ -1, /* => no useful mapping to any calendar field, can't use protected Calendar.BASE_FIELD_COUNT */
|
||
|
|
};
|
||
|
|
|
||
|
|
// Map pattern character index to DateFormat field number
|
||
|
|
private static final int[] PATTERN_INDEX_TO_DATE_FORMAT_FIELD = {
|
||
|
|
/*GyM*/ DateFormat.ERA_FIELD, DateFormat.YEAR_FIELD, DateFormat.MONTH_FIELD,
|
||
|
|
/*dkH*/ DateFormat.DATE_FIELD, DateFormat.HOUR_OF_DAY1_FIELD, DateFormat.HOUR_OF_DAY0_FIELD,
|
||
|
|
/*msS*/ DateFormat.MINUTE_FIELD, DateFormat.SECOND_FIELD, DateFormat.FRACTIONAL_SECOND_FIELD,
|
||
|
|
/*EDF*/ DateFormat.DAY_OF_WEEK_FIELD, DateFormat.DAY_OF_YEAR_FIELD, DateFormat.DAY_OF_WEEK_IN_MONTH_FIELD,
|
||
|
|
/*wWa*/ DateFormat.WEEK_OF_YEAR_FIELD, DateFormat.WEEK_OF_MONTH_FIELD, DateFormat.AM_PM_FIELD,
|
||
|
|
/*hKz*/ DateFormat.HOUR1_FIELD, DateFormat.HOUR0_FIELD, DateFormat.TIMEZONE_FIELD,
|
||
|
|
/*Yeu*/ DateFormat.YEAR_WOY_FIELD, DateFormat.DOW_LOCAL_FIELD, DateFormat.EXTENDED_YEAR_FIELD,
|
||
|
|
/*gAZ*/ DateFormat.JULIAN_DAY_FIELD, DateFormat.MILLISECONDS_IN_DAY_FIELD, DateFormat.TIMEZONE_RFC_FIELD,
|
||
|
|
/*v*/ DateFormat.TIMEZONE_GENERIC_FIELD,
|
||
|
|
/*c*/ DateFormat.STANDALONE_DAY_FIELD,
|
||
|
|
/*L*/ DateFormat.STANDALONE_MONTH_FIELD,
|
||
|
|
/*Qq*/ DateFormat.QUARTER_FIELD, DateFormat.STANDALONE_QUARTER_FIELD,
|
||
|
|
/*V*/ DateFormat.TIMEZONE_SPECIAL_FIELD,
|
||
|
|
/*U*/ DateFormat.YEAR_NAME_FIELD,
|
||
|
|
/*O*/ DateFormat.TIMEZONE_LOCALIZED_GMT_OFFSET_FIELD,
|
||
|
|
/*Xx*/ DateFormat.TIMEZONE_ISO_FIELD, DateFormat.TIMEZONE_ISO_LOCAL_FIELD,
|
||
|
|
/*r*/ DateFormat.RELATED_YEAR,
|
||
|
|
/*bB*/ DateFormat.AM_PM_MIDNIGHT_NOON_FIELD, DateFormat.FLEXIBLE_DAY_PERIOD_FIELD,
|
||
|
|
/*(no pattern character defined for this)*/ DateFormat.TIME_SEPARATOR,
|
||
|
|
};
|
||
|
|
|
||
|
|
// Map pattern character index to DateFormat.Field
|
||
|
|
private static final DateFormat.Field[] PATTERN_INDEX_TO_DATE_FORMAT_ATTRIBUTE = {
|
||
|
|
/*GyM*/ DateFormat.Field.ERA, DateFormat.Field.YEAR, DateFormat.Field.MONTH,
|
||
|
|
/*dkH*/ DateFormat.Field.DAY_OF_MONTH, DateFormat.Field.HOUR_OF_DAY1, DateFormat.Field.HOUR_OF_DAY0,
|
||
|
|
/*msS*/ DateFormat.Field.MINUTE, DateFormat.Field.SECOND, DateFormat.Field.MILLISECOND,
|
||
|
|
/*EDF*/ DateFormat.Field.DAY_OF_WEEK, DateFormat.Field.DAY_OF_YEAR, DateFormat.Field.DAY_OF_WEEK_IN_MONTH,
|
||
|
|
/*wWa*/ DateFormat.Field.WEEK_OF_YEAR, DateFormat.Field.WEEK_OF_MONTH, DateFormat.Field.AM_PM,
|
||
|
|
/*hKz*/ DateFormat.Field.HOUR1, DateFormat.Field.HOUR0, DateFormat.Field.TIME_ZONE,
|
||
|
|
/*Yeu*/ DateFormat.Field.YEAR_WOY, DateFormat.Field.DOW_LOCAL, DateFormat.Field.EXTENDED_YEAR,
|
||
|
|
/*gAZ*/ DateFormat.Field.JULIAN_DAY, DateFormat.Field.MILLISECONDS_IN_DAY, DateFormat.Field.TIME_ZONE,
|
||
|
|
/*v*/ DateFormat.Field.TIME_ZONE,
|
||
|
|
/*c*/ DateFormat.Field.DAY_OF_WEEK,
|
||
|
|
/*L*/ DateFormat.Field.MONTH,
|
||
|
|
/*Qq*/ DateFormat.Field.QUARTER, DateFormat.Field.QUARTER,
|
||
|
|
/*V*/ DateFormat.Field.TIME_ZONE,
|
||
|
|
/*U*/ DateFormat.Field.YEAR,
|
||
|
|
/*O*/ DateFormat.Field.TIME_ZONE,
|
||
|
|
/*Xx*/ DateFormat.Field.TIME_ZONE, DateFormat.Field.TIME_ZONE,
|
||
|
|
/*r*/ DateFormat.Field.RELATED_YEAR,
|
||
|
|
/*bB*/ DateFormat.Field.AM_PM_MIDNIGHT_NOON, DateFormat.Field.FLEXIBLE_DAY_PERIOD,
|
||
|
|
/*(no pattern character defined for this)*/ DateFormat.Field.TIME_SEPARATOR,
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns a DateFormat.Field constant associated with the specified format pattern
|
||
|
|
* character.
|
||
|
|
*
|
||
|
|
* @param ch The pattern character
|
||
|
|
* @return DateFormat.Field associated with the pattern character
|
||
|
|
*/
|
||
|
|
protected DateFormat.Field patternCharToDateFormatField(char ch) {
|
||
|
|
int patternCharIndex = getIndexFromChar(ch);
|
||
|
|
if (patternCharIndex != -1) {
|
||
|
|
return PATTERN_INDEX_TO_DATE_FORMAT_ATTRIBUTE[patternCharIndex];
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Formats a single field, given its pattern character. Subclasses may
|
||
|
|
* override this method in order to modify or add formatting
|
||
|
|
* capabilities.
|
||
|
|
* @param ch the pattern character
|
||
|
|
* @param count the number of times ch is repeated in the pattern
|
||
|
|
* @param beginOffset the offset of the output string at the start of
|
||
|
|
* this field; used to set pos when appropriate
|
||
|
|
* @param pos receives the position of a field, when appropriate
|
||
|
|
* @param fmtData the symbols for this formatter
|
||
|
|
*/
|
||
|
|
protected String subFormat(char ch, int count, int beginOffset,
|
||
|
|
FieldPosition pos, DateFormatSymbols fmtData,
|
||
|
|
Calendar cal)
|
||
|
|
throws IllegalArgumentException
|
||
|
|
{
|
||
|
|
// Note: formatData is ignored
|
||
|
|
return subFormat(ch, count, beginOffset, 0, DisplayContext.CAPITALIZATION_NONE, pos, ch, cal);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Formats a single field. This is the version called internally; it
|
||
|
|
* adds fieldNum and capitalizationContext parameters.
|
||
|
|
*
|
||
|
|
* @deprecated This API is ICU internal only.
|
||
|
|
* @hide draft / provisional / internal are hidden on Android
|
||
|
|
*/
|
||
|
|
@Deprecated
|
||
|
|
protected String subFormat(char ch, int count, int beginOffset,
|
||
|
|
int fieldNum, DisplayContext capitalizationContext,
|
||
|
|
FieldPosition pos,
|
||
|
|
char patternCharToOutput,
|
||
|
|
Calendar cal)
|
||
|
|
{
|
||
|
|
StringBuffer buf = new StringBuffer();
|
||
|
|
subFormat(buf, ch, count, beginOffset, fieldNum, capitalizationContext, pos, patternCharToOutput, cal);
|
||
|
|
return buf.toString();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Formats a single field; useFastFormat variant. Reuses a
|
||
|
|
* StringBuffer for results instead of creating a String on the
|
||
|
|
* heap for each call.
|
||
|
|
*
|
||
|
|
* NOTE We don't really need the beginOffset parameter, EXCEPT for
|
||
|
|
* the need to support the slow subFormat variant (above) which
|
||
|
|
* has to pass it in to us.
|
||
|
|
*
|
||
|
|
* @deprecated This API is ICU internal only.
|
||
|
|
* @hide draft / provisional / internal are hidden on Android
|
||
|
|
*/
|
||
|
|
@Deprecated
|
||
|
|
@SuppressWarnings("fallthrough")
|
||
|
|
protected void subFormat(StringBuffer buf,
|
||
|
|
char ch, int count, int beginOffset,
|
||
|
|
int fieldNum, DisplayContext capitalizationContext,
|
||
|
|
FieldPosition pos,
|
||
|
|
char patternCharToOutput,
|
||
|
|
Calendar cal) {
|
||
|
|
|
||
|
|
final int maxIntCount = Integer.MAX_VALUE;
|
||
|
|
final int bufstart = buf.length();
|
||
|
|
TimeZone tz = cal.getTimeZone();
|
||
|
|
long date = cal.getTimeInMillis();
|
||
|
|
String result = null;
|
||
|
|
|
||
|
|
int patternCharIndex = getIndexFromChar(ch);
|
||
|
|
if (patternCharIndex == -1) {
|
||
|
|
if (ch == 'l') { // (SMALL LETTER L) deprecated placeholder for leap month marker, ignore
|
||
|
|
return;
|
||
|
|
} else {
|
||
|
|
throw new IllegalArgumentException("Illegal pattern character " +
|
||
|
|
"'" + ch + "' in \"" +
|
||
|
|
pattern + '"');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
final int field = PATTERN_INDEX_TO_CALENDAR_FIELD[patternCharIndex];
|
||
|
|
int value = 0;
|
||
|
|
// Don't get value unless it is useful
|
||
|
|
if (field >= 0) {
|
||
|
|
value = (patternCharIndex != DateFormat.RELATED_YEAR)? cal.get(field): cal.getRelatedYear();
|
||
|
|
}
|
||
|
|
|
||
|
|
NumberFormat currentNumberFormat = getNumberFormat(ch);
|
||
|
|
DateFormatSymbols.CapitalizationContextUsage capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.OTHER;
|
||
|
|
|
||
|
|
switch (patternCharIndex) {
|
||
|
|
case 0: // 'G' - ERA
|
||
|
|
if ( cal.getType().equals("chinese") || cal.getType().equals("dangi") ) {
|
||
|
|
// moved from ChineseDateFormat
|
||
|
|
zeroPaddingNumber(currentNumberFormat, buf, value, 1, 9);
|
||
|
|
} else {
|
||
|
|
if (count == 5) {
|
||
|
|
safeAppend(formatData.narrowEras, value, buf);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.ERA_NARROW;
|
||
|
|
} else if (count == 4) {
|
||
|
|
safeAppend(formatData.eraNames, value, buf);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.ERA_WIDE;
|
||
|
|
} else {
|
||
|
|
safeAppend(formatData.eras, value, buf);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.ERA_ABBREV;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 30: // 'U' - YEAR_NAME_FIELD
|
||
|
|
if (formatData.shortYearNames != null && value <= formatData.shortYearNames.length) {
|
||
|
|
safeAppend(formatData.shortYearNames, value-1, buf);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
// else fall through to numeric year handling, do not break here
|
||
|
|
case 1: // 'y' - YEAR
|
||
|
|
case 18: // 'Y' - YEAR_WOY
|
||
|
|
if ( override != null && (override.compareTo("hebr") == 0 || override.indexOf("y=hebr") >= 0) &&
|
||
|
|
value > HEBREW_CAL_CUR_MILLENIUM_START_YEAR && value < HEBREW_CAL_CUR_MILLENIUM_END_YEAR ) {
|
||
|
|
value -= HEBREW_CAL_CUR_MILLENIUM_START_YEAR;
|
||
|
|
}
|
||
|
|
/* According to the specification, if the number of pattern letters ('y') is 2,
|
||
|
|
* the year is truncated to 2 digits; otherwise it is interpreted as a number.
|
||
|
|
* But the original code process 'y', 'yy', 'yyy' in the same way. and process
|
||
|
|
* patterns with 4 or more than 4 'y' characters in the same way.
|
||
|
|
* So I change the codes to meet the specification. [Richard/GCl]
|
||
|
|
*/
|
||
|
|
if (count == 2) {
|
||
|
|
zeroPaddingNumber(currentNumberFormat,buf, value, 2, 2); // clip 1996 to 96
|
||
|
|
} else { //count = 1 or count > 2
|
||
|
|
zeroPaddingNumber(currentNumberFormat,buf, value, count, maxIntCount);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 2: // 'M' - MONTH
|
||
|
|
case 26: // 'L' - STANDALONE MONTH
|
||
|
|
if ( cal.getType().equals("hebrew")) {
|
||
|
|
boolean isLeap = HebrewCalendar.isLeapYear(cal.get(Calendar.YEAR));
|
||
|
|
if (isLeap && value == 6 && count >= 3 ) {
|
||
|
|
value = 13; // Show alternate form for Adar II in leap years in Hebrew calendar.
|
||
|
|
}
|
||
|
|
if (!isLeap && value >= 6 && count < 3 ) {
|
||
|
|
value--; // Adjust the month number down 1 in Hebrew non-leap years, i.e. Adar is 6, not 7.
|
||
|
|
}
|
||
|
|
}
|
||
|
|
int isLeapMonth = (formatData.leapMonthPatterns != null && formatData.leapMonthPatterns.length >= DateFormatSymbols.DT_MONTH_PATTERN_COUNT)?
|
||
|
|
cal.get(Calendar.IS_LEAP_MONTH): 0;
|
||
|
|
// should consolidate the next section by using arrays of pointers & counts for the right symbols...
|
||
|
|
if (count == 5) {
|
||
|
|
if (patternCharIndex == 2) {
|
||
|
|
safeAppendWithMonthPattern(formatData.narrowMonths, value, buf, (isLeapMonth!=0)? formatData.leapMonthPatterns[DateFormatSymbols.DT_LEAP_MONTH_PATTERN_FORMAT_NARROW]: null);
|
||
|
|
} else {
|
||
|
|
safeAppendWithMonthPattern(formatData.standaloneNarrowMonths, value, buf, (isLeapMonth!=0)? formatData.leapMonthPatterns[DateFormatSymbols.DT_LEAP_MONTH_PATTERN_STANDALONE_NARROW]: null);
|
||
|
|
}
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.MONTH_NARROW;
|
||
|
|
} else if (count == 4) {
|
||
|
|
if (patternCharIndex == 2) {
|
||
|
|
safeAppendWithMonthPattern(formatData.months, value, buf, (isLeapMonth!=0)? formatData.leapMonthPatterns[DateFormatSymbols.DT_LEAP_MONTH_PATTERN_FORMAT_WIDE]: null);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.MONTH_FORMAT;
|
||
|
|
} else {
|
||
|
|
safeAppendWithMonthPattern(formatData.standaloneMonths, value, buf, (isLeapMonth!=0)? formatData.leapMonthPatterns[DateFormatSymbols.DT_LEAP_MONTH_PATTERN_STANDALONE_WIDE]: null);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.MONTH_STANDALONE;
|
||
|
|
}
|
||
|
|
} else if (count == 3) {
|
||
|
|
if (patternCharIndex == 2) {
|
||
|
|
safeAppendWithMonthPattern(formatData.shortMonths, value, buf, (isLeapMonth!=0)? formatData.leapMonthPatterns[DateFormatSymbols.DT_LEAP_MONTH_PATTERN_FORMAT_ABBREV]: null);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.MONTH_FORMAT;
|
||
|
|
} else {
|
||
|
|
safeAppendWithMonthPattern(formatData.standaloneShortMonths, value, buf, (isLeapMonth!=0)? formatData.leapMonthPatterns[DateFormatSymbols.DT_LEAP_MONTH_PATTERN_STANDALONE_ABBREV]: null);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.MONTH_STANDALONE;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
StringBuffer monthNumber = new StringBuffer();
|
||
|
|
zeroPaddingNumber(currentNumberFormat, monthNumber, value+1, count, maxIntCount);
|
||
|
|
String[] monthNumberStrings = new String[1];
|
||
|
|
monthNumberStrings[0] = monthNumber.toString();
|
||
|
|
safeAppendWithMonthPattern(monthNumberStrings, 0, buf, (isLeapMonth!=0)? formatData.leapMonthPatterns[DateFormatSymbols.DT_LEAP_MONTH_PATTERN_NUMERIC]: null);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 4: // 'k' - HOUR_OF_DAY (1..24)
|
||
|
|
if (value == 0) {
|
||
|
|
zeroPaddingNumber(currentNumberFormat,buf,
|
||
|
|
cal.getMaximum(Calendar.HOUR_OF_DAY)+1,
|
||
|
|
count, maxIntCount);
|
||
|
|
} else {
|
||
|
|
zeroPaddingNumber(currentNumberFormat,buf, value, count, maxIntCount);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 8: // 'S' - FRACTIONAL_SECOND
|
||
|
|
// Fractional seconds left-justify
|
||
|
|
{
|
||
|
|
numberFormat.setMinimumIntegerDigits(Math.min(3, count));
|
||
|
|
numberFormat.setMaximumIntegerDigits(maxIntCount);
|
||
|
|
if (count == 1) {
|
||
|
|
value /= 100;
|
||
|
|
} else if (count == 2) {
|
||
|
|
value /= 10;
|
||
|
|
}
|
||
|
|
FieldPosition p = new FieldPosition(-1);
|
||
|
|
numberFormat.format(value, buf, p);
|
||
|
|
if (count > 3) {
|
||
|
|
numberFormat.setMinimumIntegerDigits(count - 3);
|
||
|
|
numberFormat.format(0L, buf, p);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 19: // 'e' - DOW_LOCAL (use DOW_LOCAL for numeric, DAY_OF_WEEK for format names)
|
||
|
|
if (count < 3) {
|
||
|
|
zeroPaddingNumber(currentNumberFormat,buf, value, count, maxIntCount);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
// For alpha day-of-week, we don't want DOW_LOCAL,
|
||
|
|
// we need the standard DAY_OF_WEEK.
|
||
|
|
value = cal.get(Calendar.DAY_OF_WEEK);
|
||
|
|
// fall through, do not break here
|
||
|
|
case 9: // 'E' - DAY_OF_WEEK
|
||
|
|
if (count == 5) {
|
||
|
|
safeAppend(formatData.narrowWeekdays, value, buf);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.DAY_NARROW;
|
||
|
|
} else if (count == 4) {
|
||
|
|
safeAppend(formatData.weekdays, value, buf);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.DAY_FORMAT;
|
||
|
|
} else if (count == 6 && formatData.shorterWeekdays != null) {
|
||
|
|
safeAppend(formatData.shorterWeekdays, value, buf);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.DAY_FORMAT;
|
||
|
|
} else {// count <= 3, use abbreviated form if exists
|
||
|
|
safeAppend(formatData.shortWeekdays, value, buf);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.DAY_FORMAT;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 14: // 'a' - AM_PM
|
||
|
|
// formatData.ampmsNarrow may be null when deserializing DateFormatSymbolsfrom old version
|
||
|
|
if (count < 5 || formatData.ampmsNarrow == null) {
|
||
|
|
safeAppend(formatData.ampms, value, buf);
|
||
|
|
} else {
|
||
|
|
safeAppend(formatData.ampmsNarrow, value, buf);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 15: // 'h' - HOUR (1..12)
|
||
|
|
if (value == 0) {
|
||
|
|
zeroPaddingNumber(currentNumberFormat,buf,
|
||
|
|
cal.getLeastMaximum(Calendar.HOUR)+1,
|
||
|
|
count, maxIntCount);
|
||
|
|
} else {
|
||
|
|
zeroPaddingNumber(currentNumberFormat,buf, value, count, maxIntCount);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 17: // 'z' - TIMEZONE_FIELD
|
||
|
|
if (count < 4) {
|
||
|
|
// "z", "zz", "zzz"
|
||
|
|
result = tzFormat().format(Style.SPECIFIC_SHORT, tz, date);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.METAZONE_SHORT;
|
||
|
|
} else {
|
||
|
|
result = tzFormat().format(Style.SPECIFIC_LONG, tz, date);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.METAZONE_LONG;
|
||
|
|
}
|
||
|
|
buf.append(result);
|
||
|
|
break;
|
||
|
|
case 23: // 'Z' - TIMEZONE_RFC_FIELD
|
||
|
|
if (count < 4) {
|
||
|
|
// RFC822 format - equivalent to ISO 8601 local offset fixed width format
|
||
|
|
result = tzFormat().format(Style.ISO_BASIC_LOCAL_FULL, tz, date);
|
||
|
|
} else if (count == 5) {
|
||
|
|
// ISO 8601 extended format
|
||
|
|
result = tzFormat().format(Style.ISO_EXTENDED_FULL, tz, date);
|
||
|
|
} else {
|
||
|
|
// long form, localized GMT pattern
|
||
|
|
result = tzFormat().format(Style.LOCALIZED_GMT, tz, date);
|
||
|
|
}
|
||
|
|
buf.append(result);
|
||
|
|
break;
|
||
|
|
case 24: // 'v' - TIMEZONE_GENERIC_FIELD
|
||
|
|
if (count == 1) {
|
||
|
|
// "v"
|
||
|
|
result = tzFormat().format(Style.GENERIC_SHORT, tz, date);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.METAZONE_SHORT;
|
||
|
|
} else if (count == 4) {
|
||
|
|
// "vvvv"
|
||
|
|
result = tzFormat().format(Style.GENERIC_LONG, tz, date);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.METAZONE_LONG;
|
||
|
|
}
|
||
|
|
buf.append(result);
|
||
|
|
break;
|
||
|
|
case 29: // 'V' - TIMEZONE_SPECIAL_FIELD
|
||
|
|
if (count == 1) {
|
||
|
|
// "V"
|
||
|
|
result = tzFormat().format(Style.ZONE_ID_SHORT, tz, date);
|
||
|
|
} else if (count == 2) {
|
||
|
|
// "VV"
|
||
|
|
result = tzFormat().format(Style.ZONE_ID, tz, date);
|
||
|
|
} else if (count == 3) {
|
||
|
|
// "VVV"
|
||
|
|
result = tzFormat().format(Style.EXEMPLAR_LOCATION, tz, date);
|
||
|
|
} else if (count == 4) {
|
||
|
|
// "VVVV"
|
||
|
|
result = tzFormat().format(Style.GENERIC_LOCATION, tz, date);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.ZONE_LONG;
|
||
|
|
}
|
||
|
|
buf.append(result);
|
||
|
|
break;
|
||
|
|
case 31: // 'O' - TIMEZONE_LOCALIZED_GMT_OFFSET_FIELD
|
||
|
|
if (count == 1) {
|
||
|
|
// "O" - Short Localized GMT format
|
||
|
|
result = tzFormat().format(Style.LOCALIZED_GMT_SHORT, tz, date);
|
||
|
|
} else if (count == 4) {
|
||
|
|
// "OOOO" - Localized GMT format
|
||
|
|
result = tzFormat().format(Style.LOCALIZED_GMT, tz, date);
|
||
|
|
}
|
||
|
|
buf.append(result);
|
||
|
|
break;
|
||
|
|
case 32: // 'X' - TIMEZONE_ISO_FIELD
|
||
|
|
if (count == 1) {
|
||
|
|
// "X" - ISO Basic/Short
|
||
|
|
result = tzFormat().format(Style.ISO_BASIC_SHORT, tz, date);
|
||
|
|
} else if (count == 2) {
|
||
|
|
// "XX" - ISO Basic/Fixed
|
||
|
|
result = tzFormat().format(Style.ISO_BASIC_FIXED, tz, date);
|
||
|
|
} else if (count == 3) {
|
||
|
|
// "XXX" - ISO Extended/Fixed
|
||
|
|
result = tzFormat().format(Style.ISO_EXTENDED_FIXED, tz, date);
|
||
|
|
} else if (count == 4) {
|
||
|
|
// "XXXX" - ISO Basic/Optional second field
|
||
|
|
result = tzFormat().format(Style.ISO_BASIC_FULL, tz, date);
|
||
|
|
} else if (count == 5) {
|
||
|
|
// "XXXXX" - ISO Extended/Optional second field
|
||
|
|
result = tzFormat().format(Style.ISO_EXTENDED_FULL, tz, date);
|
||
|
|
}
|
||
|
|
buf.append(result);
|
||
|
|
break;
|
||
|
|
case 33: // 'x' - TIMEZONE_ISO_LOCAL_FIELD
|
||
|
|
if (count == 1) {
|
||
|
|
// "x" - ISO Local Basic/Short
|
||
|
|
result = tzFormat().format(Style.ISO_BASIC_LOCAL_SHORT, tz, date);
|
||
|
|
} else if (count == 2) {
|
||
|
|
// "x" - ISO Local Basic/Fixed
|
||
|
|
result = tzFormat().format(Style.ISO_BASIC_LOCAL_FIXED, tz, date);
|
||
|
|
} else if (count == 3) {
|
||
|
|
// "xxx" - ISO Local Extended/Fixed
|
||
|
|
result = tzFormat().format(Style.ISO_EXTENDED_LOCAL_FIXED, tz, date);
|
||
|
|
} else if (count == 4) {
|
||
|
|
// "xxxx" - ISO Local Basic/Optional second field
|
||
|
|
result = tzFormat().format(Style.ISO_BASIC_LOCAL_FULL, tz, date);
|
||
|
|
} else if (count == 5) {
|
||
|
|
// "xxxxx" - ISO Local Extended/Optional second field
|
||
|
|
result = tzFormat().format(Style.ISO_EXTENDED_LOCAL_FULL, tz, date);
|
||
|
|
}
|
||
|
|
buf.append(result);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 25: // 'c' - STANDALONE DAY (use DOW_LOCAL for numeric, DAY_OF_WEEK for standalone)
|
||
|
|
if (count < 3) {
|
||
|
|
zeroPaddingNumber(currentNumberFormat,buf, value, 1, maxIntCount);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
// For alpha day-of-week, we don't want DOW_LOCAL,
|
||
|
|
// we need the standard DAY_OF_WEEK.
|
||
|
|
value = cal.get(Calendar.DAY_OF_WEEK);
|
||
|
|
if (count == 5) {
|
||
|
|
safeAppend(formatData.standaloneNarrowWeekdays, value, buf);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.DAY_NARROW;
|
||
|
|
} else if (count == 4) {
|
||
|
|
safeAppend(formatData.standaloneWeekdays, value, buf);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.DAY_STANDALONE;
|
||
|
|
} else if (count == 6 && formatData.standaloneShorterWeekdays != null) {
|
||
|
|
safeAppend(formatData.standaloneShorterWeekdays, value, buf);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.DAY_STANDALONE;
|
||
|
|
} else { // count == 3
|
||
|
|
safeAppend(formatData.standaloneShortWeekdays, value, buf);
|
||
|
|
capContextUsageType = DateFormatSymbols.CapitalizationContextUsage.DAY_STANDALONE;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 27: // 'Q' - QUARTER
|
||
|
|
if (count >= 5) {
|
||
|
|
safeAppend(formatData.narrowQuarters, value/3, buf);
|
||
|
|
} else if (count == 4) {
|
||
|
|
safeAppend(formatData.quarters, value/3, buf);
|
||
|
|
} else if (count == 3) {
|
||
|
|
safeAppend(formatData.shortQuarters, value/3, buf);
|
||
|
|
} else {
|
||
|
|
zeroPaddingNumber(currentNumberFormat,buf, (value/3)+1, count, maxIntCount);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 28: // 'q' - STANDALONE QUARTER
|
||
|
|
if (count >= 5) {
|
||
|
|
safeAppend(formatData.standaloneNarrowQuarters, value/3, buf);
|
||
|
|
} else if (count == 4) {
|
||
|
|
safeAppend(formatData.standaloneQuarters, value/3, buf);
|
||
|
|
} else if (count == 3) {
|
||
|
|
safeAppend(formatData.standaloneShortQuarters, value/3, buf);
|
||
|
|
} else {
|
||
|
|
zeroPaddingNumber(currentNumberFormat,buf, (value/3)+1, count, maxIntCount);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 35: // 'b' - am/pm/noon/midnight
|
||
|
|
{
|
||
|
|
// Note: "midnight" can be ambiguous as to whether it refers to beginning of day or end of day.
|
||
|
|
// For ICU 57 output of "midnight" is temporarily suppressed.
|
||
|
|
|
||
|
|
int hour = cal.get(Calendar.HOUR_OF_DAY);
|
||
|
|
String toAppend = null;
|
||
|
|
|
||
|
|
// For "midnight" and "noon":
|
||
|
|
// Time, as displayed, must be exactly noon or midnight.
|
||
|
|
// This means minutes and seconds, if present, must be zero.
|
||
|
|
if ((/*hour == 0 ||*/ hour == 12) &&
|
||
|
|
(!hasMinute || cal.get(Calendar.MINUTE) == 0) &&
|
||
|
|
(!hasSecond || cal.get(Calendar.SECOND) == 0)) {
|
||
|
|
// Stealing am/pm value to use as our array index.
|
||
|
|
// It works out: am/midnight are both 0, pm/noon are both 1,
|
||
|
|
// 12 am is 12 midnight, and 12 pm is 12 noon.
|
||
|
|
value = cal.get(Calendar.AM_PM);
|
||
|
|
|
||
|
|
if (count <= 3) {
|
||
|
|
toAppend = formatData.abbreviatedDayPeriods[value];
|
||
|
|
} else if (count == 4 || count > 5) {
|
||
|
|
toAppend = formatData.wideDayPeriods[value];
|
||
|
|
} else { // count == 5
|
||
|
|
toAppend = formatData.narrowDayPeriods[value];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (toAppend == null) {
|
||
|
|
// Time isn't exactly midnight or noon (as displayed) or localized string doesn't
|
||
|
|
// exist for requested period. Fall back to am/pm instead.
|
||
|
|
// We are passing a different patternCharToOutput because we want to add
|
||
|
|
// 'b' to field position. This makes this fallback stable when
|
||
|
|
// there is a data change on locales.
|
||
|
|
subFormat(buf, 'a', count, beginOffset, fieldNum, capitalizationContext, pos, 'b', cal);
|
||
|
|
} else {
|
||
|
|
buf.append(toAppend);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 36: // 'B' - flexible day period
|
||
|
|
{
|
||
|
|
// TODO: Maybe fetch the DayperiodRules during initialization (instead of at the first
|
||
|
|
// loading of an instance) if a relevant pattern character (b or B) is used.
|
||
|
|
DayPeriodRules ruleSet = DayPeriodRules.getInstance(getLocale());
|
||
|
|
if (ruleSet == null) {
|
||
|
|
// Data doesn't exist for the locale we're looking for.
|
||
|
|
// Fall back to am/pm.
|
||
|
|
// We are passing a different patternCharToOutput because we want to add
|
||
|
|
// 'B' to field position. This makes this fallback stable when
|
||
|
|
// there is a data change on locales.
|
||
|
|
subFormat(buf, 'a', count, beginOffset, fieldNum, capitalizationContext, pos, 'B', cal);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get current display time.
|
||
|
|
int hour = cal.get(Calendar.HOUR_OF_DAY);
|
||
|
|
int minute = 0;
|
||
|
|
int second = 0;
|
||
|
|
if (hasMinute) { minute = cal.get(Calendar.MINUTE); }
|
||
|
|
if (hasSecond) { second = cal.get(Calendar.SECOND); }
|
||
|
|
|
||
|
|
// Determine day period.
|
||
|
|
DayPeriodRules.DayPeriod periodType;
|
||
|
|
if (hour == 0 && minute == 0 && second == 0 && ruleSet.hasMidnight()) {
|
||
|
|
periodType = DayPeriodRules.DayPeriod.MIDNIGHT;
|
||
|
|
} else if (hour == 12 && minute == 0 && second == 0 && ruleSet.hasNoon()) {
|
||
|
|
periodType = DayPeriodRules.DayPeriod.NOON;
|
||
|
|
} else {
|
||
|
|
periodType = ruleSet.getDayPeriodForHour(hour);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Note: "midnight" can be ambiguous as to whether it refers to beginning of day or end of day.
|
||
|
|
// For ICU 57 output of "midnight" is temporarily suppressed.
|
||
|
|
|
||
|
|
// Rule set exists, therefore periodType can't be null.
|
||
|
|
// Get localized string.
|
||
|
|
assert(periodType != null);
|
||
|
|
String toAppend = null;
|
||
|
|
int index;
|
||
|
|
|
||
|
|
if (periodType != DayPeriodRules.DayPeriod.AM && periodType != DayPeriodRules.DayPeriod.PM &&
|
||
|
|
periodType != DayPeriodRules.DayPeriod.MIDNIGHT) {
|
||
|
|
index = periodType.ordinal();
|
||
|
|
if (count <= 3) {
|
||
|
|
toAppend = formatData.abbreviatedDayPeriods[index]; // i.e. short
|
||
|
|
} else if (count == 4 || count > 5) {
|
||
|
|
toAppend = formatData.wideDayPeriods[index];
|
||
|
|
} else { // count == 5
|
||
|
|
toAppend = formatData.narrowDayPeriods[index];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// Fallback schedule:
|
||
|
|
// Midnight/Noon -> General Periods -> AM/PM.
|
||
|
|
|
||
|
|
// Midnight/Noon -> General Periods.
|
||
|
|
if (toAppend == null &&
|
||
|
|
(periodType == DayPeriodRules.DayPeriod.MIDNIGHT ||
|
||
|
|
periodType == DayPeriodRules.DayPeriod.NOON)) {
|
||
|
|
periodType = ruleSet.getDayPeriodForHour(hour);
|
||
|
|
index = periodType.ordinal();
|
||
|
|
|
||
|
|
if (count <= 3) {
|
||
|
|
toAppend = formatData.abbreviatedDayPeriods[index]; // i.e. short
|
||
|
|
} else if (count == 4 || count > 5) {
|
||
|
|
toAppend = formatData.wideDayPeriods[index];
|
||
|
|
} else { // count == 5
|
||
|
|
toAppend = formatData.narrowDayPeriods[index];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// General Periods -> AM/PM.
|
||
|
|
if (periodType == DayPeriodRules.DayPeriod.AM ||
|
||
|
|
periodType == DayPeriodRules.DayPeriod.PM ||
|
||
|
|
toAppend == null) {
|
||
|
|
// We are passing a different patternCharToOutput because we want to add
|
||
|
|
// 'B' to field position. This makes this fallback stable when
|
||
|
|
// there is a data change on locales.
|
||
|
|
subFormat(buf, 'a', count, beginOffset, fieldNum, capitalizationContext, pos, 'B', cal);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
buf.append(toAppend);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 37: // TIME SEPARATOR (no pattern character currently defined, we should
|
||
|
|
// not get here but leave support in for future definition.
|
||
|
|
buf.append(formatData.getTimeSeparatorString());
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
// case 3: // 'd' - DATE
|
||
|
|
// case 5: // 'H' - HOUR_OF_DAY (0..23)
|
||
|
|
// case 6: // 'm' - MINUTE
|
||
|
|
// case 7: // 's' - SECOND
|
||
|
|
// case 10: // 'D' - DAY_OF_YEAR
|
||
|
|
// case 11: // 'F' - DAY_OF_WEEK_IN_MONTH
|
||
|
|
// case 12: // 'w' - WEEK_OF_YEAR
|
||
|
|
// case 13: // 'W' - WEEK_OF_MONTH
|
||
|
|
// case 16: // 'K' - HOUR (0..11)
|
||
|
|
// case 20: // 'u' - EXTENDED_YEAR
|
||
|
|
// case 21: // 'g' - JULIAN_DAY
|
||
|
|
// case 22: // 'A' - MILLISECONDS_IN_DAY
|
||
|
|
|
||
|
|
zeroPaddingNumber(currentNumberFormat,buf, value, count, maxIntCount);
|
||
|
|
break;
|
||
|
|
} // switch (patternCharIndex)
|
||
|
|
|
||
|
|
if (fieldNum == 0 && capitalizationContext != null && buf.length() > bufstart &&
|
||
|
|
UCharacter.isLowerCase(buf.codePointAt(bufstart))) {
|
||
|
|
boolean titlecase = false;
|
||
|
|
switch (capitalizationContext) {
|
||
|
|
case CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE:
|
||
|
|
titlecase = true;
|
||
|
|
break;
|
||
|
|
case CAPITALIZATION_FOR_UI_LIST_OR_MENU:
|
||
|
|
case CAPITALIZATION_FOR_STANDALONE:
|
||
|
|
if (formatData.capitalization != null) {
|
||
|
|
boolean[] transforms = formatData.capitalization.get(capContextUsageType);
|
||
|
|
titlecase = (capitalizationContext==DisplayContext.CAPITALIZATION_FOR_UI_LIST_OR_MENU)?
|
||
|
|
transforms[0]: transforms[1];
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (titlecase) {
|
||
|
|
if (capitalizationBrkIter == null) {
|
||
|
|
// should only happen when deserializing, etc.
|
||
|
|
capitalizationBrkIter = BreakIterator.getSentenceInstance(locale);
|
||
|
|
}
|
||
|
|
// Note, the call to UCharacter.toTitleCase below is the only place that
|
||
|
|
// (the clone of) capitalizationBrkIter is actually used.
|
||
|
|
BreakIterator mutableCapitalizationBrkIter = (BreakIterator)capitalizationBrkIter.clone();
|
||
|
|
String firstField = buf.substring(bufstart); // bufstart or beginOffset, should be the same
|
||
|
|
String firstFieldTitleCase = UCharacter.toTitleCase(locale, firstField, mutableCapitalizationBrkIter,
|
||
|
|
UCharacter.TITLECASE_NO_LOWERCASE | UCharacter.TITLECASE_NO_BREAK_ADJUSTMENT);
|
||
|
|
buf.replace(bufstart, buf.length(), firstFieldTitleCase);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Set the FieldPosition (for the first occurrence only)
|
||
|
|
int outputCharIndex = getIndexFromChar(patternCharToOutput);
|
||
|
|
if (pos.getBeginIndex() == pos.getEndIndex()) {
|
||
|
|
if (pos.getField() == PATTERN_INDEX_TO_DATE_FORMAT_FIELD[outputCharIndex]) {
|
||
|
|
pos.setBeginIndex(beginOffset);
|
||
|
|
pos.setEndIndex(beginOffset + buf.length() - bufstart);
|
||
|
|
} else if (pos.getFieldAttribute() ==
|
||
|
|
PATTERN_INDEX_TO_DATE_FORMAT_ATTRIBUTE[outputCharIndex]) {
|
||
|
|
pos.setBeginIndex(beginOffset);
|
||
|
|
pos.setEndIndex(beginOffset + buf.length() - bufstart);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static void safeAppend(String[] array, int value, StringBuffer appendTo) {
|
||
|
|
if (array != null && value >= 0 && value < array.length) {
|
||
|
|
appendTo.append(array[value]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static void safeAppendWithMonthPattern(String[] array, int value, StringBuffer appendTo, String monthPattern) {
|
||
|
|
if (array != null && value >= 0 && value < array.length) {
|
||
|
|
if (monthPattern == null) {
|
||
|
|
appendTo.append(array[value]);
|
||
|
|
} else {
|
||
|
|
String s = SimpleFormatterImpl.formatRawPattern(monthPattern, 1, 1, array[value]);
|
||
|
|
appendTo.append(s);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* PatternItem store parsed date/time field pattern information.
|
||
|
|
*/
|
||
|
|
private static class PatternItem {
|
||
|
|
final char type;
|
||
|
|
final int length;
|
||
|
|
final boolean isNumeric;
|
||
|
|
|
||
|
|
PatternItem(char type, int length) {
|
||
|
|
this.type = type;
|
||
|
|
this.length = length;
|
||
|
|
isNumeric = isNumeric(type, length);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static ICUCache<String, Object[]> PARSED_PATTERN_CACHE =
|
||
|
|
new SimpleCache<>();
|
||
|
|
private transient Object[] patternItems;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Returns parsed pattern items. Each item is either String or
|
||
|
|
* PatternItem.
|
||
|
|
*/
|
||
|
|
private Object[] getPatternItems() {
|
||
|
|
if (patternItems != null) {
|
||
|
|
return patternItems;
|
||
|
|
}
|
||
|
|
|
||
|
|
patternItems = PARSED_PATTERN_CACHE.get(pattern);
|
||
|
|
if (patternItems != null) {
|
||
|
|
return patternItems;
|
||
|
|
}
|
||
|
|
|
||
|
|
boolean isPrevQuote = false;
|
||
|
|
boolean inQuote = false;
|
||
|
|
StringBuilder text = new StringBuilder();
|
||
|
|
char itemType = 0; // 0 for string literal, otherwise date/time pattern character
|
||
|
|
int itemLength = 1;
|
||
|
|
|
||
|
|
List<Object> items = new ArrayList<>();
|
||
|
|
|
||
|
|
for (int i = 0; i < pattern.length(); i++) {
|
||
|
|
char ch = pattern.charAt(i);
|
||
|
|
if (ch == '\'') {
|
||
|
|
if (isPrevQuote) {
|
||
|
|
text.append('\'');
|
||
|
|
isPrevQuote = false;
|
||
|
|
} else {
|
||
|
|
isPrevQuote = true;
|
||
|
|
if (itemType != 0) {
|
||
|
|
items.add(new PatternItem(itemType, itemLength));
|
||
|
|
itemType = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
inQuote = !inQuote;
|
||
|
|
} else {
|
||
|
|
isPrevQuote = false;
|
||
|
|
if (inQuote) {
|
||
|
|
text.append(ch);
|
||
|
|
} else {
|
||
|
|
if (isSyntaxChar(ch)) {
|
||
|
|
// a date/time pattern character
|
||
|
|
if (ch == itemType) {
|
||
|
|
itemLength++;
|
||
|
|
} else {
|
||
|
|
if (itemType == 0) {
|
||
|
|
if (text.length() > 0) {
|
||
|
|
items.add(text.toString());
|
||
|
|
text.setLength(0);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
items.add(new PatternItem(itemType, itemLength));
|
||
|
|
}
|
||
|
|
itemType = ch;
|
||
|
|
itemLength = 1;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// a string literal
|
||
|
|
if (itemType != 0) {
|
||
|
|
items.add(new PatternItem(itemType, itemLength));
|
||
|
|
itemType = 0;
|
||
|
|
}
|
||
|
|
text.append(ch);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// handle last item
|
||
|
|
if (itemType == 0) {
|
||
|
|
if (text.length() > 0) {
|
||
|
|
items.add(text.toString());
|
||
|
|
text.setLength(0);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
items.add(new PatternItem(itemType, itemLength));
|
||
|
|
}
|
||
|
|
|
||
|
|
patternItems = items.toArray(new Object[items.size()]);
|
||
|
|
|
||
|
|
PARSED_PATTERN_CACHE.put(pattern, patternItems);
|
||
|
|
|
||
|
|
return patternItems;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Internal high-speed method. Reuses a StringBuffer for results
|
||
|
|
* instead of creating a String on the heap for each call.
|
||
|
|
* @deprecated This API is ICU internal only.
|
||
|
|
* @hide original deprecated declaration
|
||
|
|
* @hide draft / provisional / internal are hidden on Android
|
||
|
|
*/
|
||
|
|
@Deprecated
|
||
|
|
protected void zeroPaddingNumber(NumberFormat nf,StringBuffer buf, int value,
|
||
|
|
int minDigits, int maxDigits) {
|
||
|
|
// Note: Indian calendar uses negative value for a calendar
|
||
|
|
// field. fastZeroPaddingNumber cannot handle negative numbers.
|
||
|
|
// BTW, it looks like a design bug in the Indian calendar...
|
||
|
|
if (useLocalZeroPaddingNumberFormat && value >= 0) {
|
||
|
|
fastZeroPaddingNumber(buf, value, minDigits, maxDigits);
|
||
|
|
} else {
|
||
|
|
nf.setMinimumIntegerDigits(minDigits);
|
||
|
|
nf.setMaximumIntegerDigits(maxDigits);
|
||
|
|
nf.format(value, buf, new FieldPosition(-1));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Overrides superclass method and
|
||
|
|
* This method also clears per field NumberFormat instances
|
||
|
|
* previously set by {@link #setNumberFormat(String, NumberFormat)}
|
||
|
|
*/
|
||
|
|
@Override
|
||
|
|
public void setNumberFormat(NumberFormat newNumberFormat) {
|
||
|
|
// Override this method to update local zero padding number formatter
|
||
|
|
super.setNumberFormat(newNumberFormat);
|
||
|
|
initLocalZeroPaddingNumberFormat();
|
||
|
|
initializeTimeZoneFormat(true);
|
||
|
|
|
||
|
|
if (numberFormatters != null) {
|
||
|
|
numberFormatters = null;
|
||
|
|
}
|
||
|
|
if (overrideMap != null) {
|
||
|
|
overrideMap = null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Initializes transient fields for fast simple numeric formatting
|
||
|
|
* code. This method should be called whenever number format is updated.
|
||
|
|
*/
|
||
|
|
private void initLocalZeroPaddingNumberFormat() {
|
||
|
|
if (numberFormat instanceof DecimalFormat) {
|
||
|
|
DecimalFormatSymbols tmpDecfs = ((DecimalFormat)numberFormat).getDecimalFormatSymbols();
|
||
|
|
String[] tmpDigits = tmpDecfs.getDigitStringsLocal();
|
||
|
|
useLocalZeroPaddingNumberFormat = true;
|
||
|
|
decDigits = new char[10];
|
||
|
|
for (int i = 0; i < 10; i++) {
|
||
|
|
if (tmpDigits[i].length() > 1) {
|
||
|
|
useLocalZeroPaddingNumberFormat = false;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
decDigits[i] = tmpDigits[i].charAt(0);
|
||
|
|
}
|
||
|
|
} else if (numberFormat instanceof DateNumberFormat) {
|
||
|
|
decDigits = ((DateNumberFormat)numberFormat).getDigits();
|
||
|
|
useLocalZeroPaddingNumberFormat = true;
|
||
|
|
} else {
|
||
|
|
useLocalZeroPaddingNumberFormat = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (useLocalZeroPaddingNumberFormat) {
|
||
|
|
decimalBuf = new char[DECIMAL_BUF_SIZE];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// If true, use local version of zero padding number format
|
||
|
|
private transient boolean useLocalZeroPaddingNumberFormat;
|
||
|
|
private transient char[] decDigits; // read-only - can be shared by multiple instances
|
||
|
|
private transient char[] decimalBuf; // mutable - one per instance
|
||
|
|
private static final int DECIMAL_BUF_SIZE = 10; // sufficient for int numbers
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Lightweight zero padding integer number format function.
|
||
|
|
*
|
||
|
|
* Note: This implementation is almost equivalent to format method in DateNumberFormat.
|
||
|
|
* In the method zeroPaddingNumber above should be able to use the one in DateNumberFormat,
|
||
|
|
* but, it does not help IBM J9's JIT to optimize the performance much. In simple repeative
|
||
|
|
* date format test case, having local implementation is ~10% faster than using one in
|
||
|
|
* DateNumberFormat on IBM J9 VM. On Sun Hotspot VM, I do not see such difference.
|
||
|
|
*
|
||
|
|
* -Yoshito
|
||
|
|
*/
|
||
|
|
private void fastZeroPaddingNumber(StringBuffer buf, int value, int minDigits, int maxDigits) {
|
||
|
|
int limit = decimalBuf.length < maxDigits ? decimalBuf.length : maxDigits;
|
||
|
|
int index = limit - 1;
|
||
|
|
while (true) {
|
||
|
|
decimalBuf[index] = decDigits[(value % 10)];
|
||
|
|
value /= 10;
|
||
|
|
if (index == 0 || value == 0) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
index--;
|
||
|
|
}
|
||
|
|
int padding = minDigits - (limit - index);
|
||
|
|
while (padding > 0 && index > 0) {
|
||
|
|
decimalBuf[--index] = decDigits[0];
|
||
|
|
padding--;
|
||
|
|
}
|
||
|
|
while (padding > 0) {
|
||
|
|
// when pattern width is longer than decimalBuf, need extra
|
||
|
|
// leading zeros - ticke#7595
|
||
|
|
buf.append(decDigits[0]);
|
||
|
|
padding--;
|
||
|
|
}
|
||
|
|
buf.append(decimalBuf, index, limit - index);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Formats a number with the specified minimum and maximum number of digits.
|
||
|
|
*/
|
||
|
|
protected String zeroPaddingNumber(long value, int minDigits, int maxDigits)
|
||
|
|
{
|
||
|
|
numberFormat.setMinimumIntegerDigits(minDigits);
|
||
|
|
numberFormat.setMaximumIntegerDigits(maxDigits);
|
||
|
|
return numberFormat.format(value);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Format characters that indicate numeric fields always.
|
||
|
|
*/
|
||
|
|
private static final String NUMERIC_FORMAT_CHARS = "ADdFgHhKkmrSsuWwYy";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Format characters that indicate numeric fields when pattern length
|
||
|
|
* is up to 2.
|
||
|
|
*/
|
||
|
|
private static final String NUMERIC_FORMAT_CHARS2 = "ceLMQq";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Return true if the given format character, occurring count
|
||
|
|
* times, represents a numeric field.
|
||
|
|
*/
|
||
|
|
private static final boolean isNumeric(char formatChar, int count) {
|
||
|
|
return NUMERIC_FORMAT_CHARS.indexOf(formatChar) >= 0
|
||
|
|
|| (count <= 2 && NUMERIC_FORMAT_CHARS2.indexOf(formatChar) >= 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Maximum range for detecting daylight offset of a time zone when parsed time zone
|
||
|
|
* string indicates it's daylight saving time, but the detected time zone does not
|
||
|
|
* observe daylight saving time at the parsed date.
|
||
|
|
*/
|
||
|
|
private static final long MAX_DAYLIGHT_DETECTION_RANGE = 30*365*24*60*60*1000L;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Overrides DateFormat
|
||
|
|
* @see DateFormat
|
||
|
|
*/
|
||
|
|
@Override
|
||
|
|
public void parse(String text, Calendar cal, ParsePosition parsePos)
|
||
|
|
{
|
||
|
|
TimeZone backupTZ = null;
|
||
|
|
Calendar resultCal = null;
|
||
|
|
if (cal != calendar && !cal.getType().equals(calendar.getType())) {
|
||
|
|
// Different calendar type
|
||
|
|
// We use the time/zone from the input calendar, but
|
||
|
|
// do not use the input calendar for field calculation.
|
||
|
|
calendar.setTimeInMillis(cal.getTimeInMillis());
|
||
|
|
backupTZ = calendar.getTimeZone();
|
||
|
|
calendar.setTimeZone(cal.getTimeZone());
|
||
|
|
resultCal = cal;
|
||
|
|
cal = calendar;
|
||
|
|
}
|
||
|
|
|
||
|
|
int pos = parsePos.getIndex();
|
||
|
|
if(pos < 0) {
|
||
|
|
parsePos.setErrorIndex(0);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
int start = pos;
|
||
|
|
|
||
|
|
// Hold the day period until everything else is parsed, because we need
|
||
|
|
// the hour to interpret time correctly.
|
||
|
|
// Using an one-element array for output parameter.
|
||
|
|
Output<DayPeriodRules.DayPeriod> dayPeriod = new Output<>(null);
|
||
|
|
|
||
|
|
Output<TimeType> tzTimeType = new Output<>(TimeType.UNKNOWN);
|
||
|
|
boolean[] ambiguousYear = { false };
|
||
|
|
|
||
|
|
// item index for the first numeric field within a contiguous numeric run
|
||
|
|
int numericFieldStart = -1;
|
||
|
|
// item length for the first numeric field within a contiguous numeric run
|
||
|
|
int numericFieldLength = 0;
|
||
|
|
// start index of numeric text run in the input text
|
||
|
|
int numericStartPos = 0;
|
||
|
|
|
||
|
|
MessageFormat numericLeapMonthFormatter = null;
|
||
|
|
if (formatData.leapMonthPatterns != null && formatData.leapMonthPatterns.length >= DateFormatSymbols.DT_MONTH_PATTERN_COUNT) {
|
||
|
|
numericLeapMonthFormatter = new MessageFormat(formatData.leapMonthPatterns[DateFormatSymbols.DT_LEAP_MONTH_PATTERN_NUMERIC], locale);
|
||
|
|
}
|
||
|
|
|
||
|
|
Object[] items = getPatternItems();
|
||
|
|
int i = 0;
|
||
|
|
while (i < items.length) {
|
||
|
|
if (items[i] instanceof PatternItem) {
|
||
|
|
// Handle pattern field
|
||
|
|
PatternItem field = (PatternItem)items[i];
|
||
|
|
if (field.isNumeric) {
|
||
|
|
// 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 (numericFieldStart == -1) {
|
||
|
|
// check if this field is followed by abutting another numeric field
|
||
|
|
if ((i + 1) < items.length
|
||
|
|
&& (items[i + 1] instanceof PatternItem)
|
||
|
|
&& ((PatternItem)items[i + 1]).isNumeric) {
|
||
|
|
// record the first numeric field within a numeric text run
|
||
|
|
numericFieldStart = i;
|
||
|
|
numericFieldLength = field.length;
|
||
|
|
numericStartPos = pos;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (numericFieldStart != -1) {
|
||
|
|
// Handle a numeric field within abutting numeric fields
|
||
|
|
int len = field.length;
|
||
|
|
if (numericFieldStart == i) {
|
||
|
|
len = numericFieldLength;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Parse a numeric field
|
||
|
|
pos = subParse(text, pos, field.type, len,
|
||
|
|
true, false, ambiguousYear, cal, numericLeapMonthFormatter, tzTimeType);
|
||
|
|
|
||
|
|
if (pos < 0) {
|
||
|
|
// If the parse fails anywhere in the numeric run, back up to the
|
||
|
|
// start of the run and use shorter pattern length for the first
|
||
|
|
// numeric field.
|
||
|
|
--numericFieldLength;
|
||
|
|
if (numericFieldLength == 0) {
|
||
|
|
// can not make shorter any more
|
||
|
|
parsePos.setIndex(start);
|
||
|
|
parsePos.setErrorIndex(pos);
|
||
|
|
if (backupTZ != null) {
|
||
|
|
calendar.setTimeZone(backupTZ);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
i = numericFieldStart;
|
||
|
|
pos = numericStartPos;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
} else if (field.type != 'l') { // (SMALL LETTER L) obsolete pattern char just gets ignored
|
||
|
|
// Handle a non-numeric field or a non-abutting numeric field
|
||
|
|
numericFieldStart = -1;
|
||
|
|
|
||
|
|
int s = pos;
|
||
|
|
pos = subParse(text, pos, field.type, field.length,
|
||
|
|
false, true, ambiguousYear, cal, numericLeapMonthFormatter, tzTimeType, dayPeriod);
|
||
|
|
|
||
|
|
if (pos < 0) {
|
||
|
|
if (pos == ISOSpecialEra) {
|
||
|
|
// era not present, in special cases allow this to continue
|
||
|
|
pos = s;
|
||
|
|
|
||
|
|
if (i+1 < items.length) {
|
||
|
|
|
||
|
|
String patl = null;
|
||
|
|
// if it will cause a class cast exception to String, we can't use it
|
||
|
|
try {
|
||
|
|
patl = (String)items[i+1];
|
||
|
|
} catch(ClassCastException cce) {
|
||
|
|
parsePos.setIndex(start);
|
||
|
|
parsePos.setErrorIndex(s);
|
||
|
|
if (backupTZ != null) {
|
||
|
|
calendar.setTimeZone(backupTZ);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// get next item in pattern
|
||
|
|
if(patl == null)
|
||
|
|
patl = (String)items[i+1];
|
||
|
|
int plen = patl.length();
|
||
|
|
int idx=0;
|
||
|
|
|
||
|
|
// White space characters found in pattern.
|
||
|
|
// Skip contiguous white spaces.
|
||
|
|
while (idx < plen) {
|
||
|
|
|
||
|
|
char pch = patl.charAt(idx);
|
||
|
|
if (PatternProps.isWhiteSpace(pch) || UCharacter.isUWhiteSpace(pch))
|
||
|
|
idx++;
|
||
|
|
else
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// if next item in pattern is all whitespace, skip it
|
||
|
|
if (idx == plen) {
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
parsePos.setIndex(start);
|
||
|
|
parsePos.setErrorIndex(s);
|
||
|
|
if (backupTZ != null) {
|
||
|
|
calendar.setTimeZone(backupTZ);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// Handle literal pattern text literal
|
||
|
|
numericFieldStart = -1;
|
||
|
|
boolean[] complete = new boolean[1];
|
||
|
|
pos = matchLiteral(text, pos, items, i, complete);
|
||
|
|
if (!complete[0]) {
|
||
|
|
// Set the position of mismatch
|
||
|
|
parsePos.setIndex(start);
|
||
|
|
parsePos.setErrorIndex(pos);
|
||
|
|
if (backupTZ != null) {
|
||
|
|
calendar.setTimeZone(backupTZ);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
++i;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Special hack for trailing "." after non-numeric field.
|
||
|
|
if (pos < text.length()) {
|
||
|
|
char extra = text.charAt(pos);
|
||
|
|
if (extra == '.' && getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_ALLOW_WHITESPACE) && items.length != 0) {
|
||
|
|
// only do if the last field is not numeric
|
||
|
|
Object lastItem = items[items.length - 1];
|
||
|
|
if (lastItem instanceof PatternItem && !((PatternItem)lastItem).isNumeric) {
|
||
|
|
pos++; // skip the extra "."
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// If dayPeriod is set, use it in conjunction with hour-of-day to determine am/pm.
|
||
|
|
if (dayPeriod.value != null) {
|
||
|
|
DayPeriodRules ruleSet = DayPeriodRules.getInstance(getLocale());
|
||
|
|
|
||
|
|
if (!cal.isSet(Calendar.HOUR) && !cal.isSet(Calendar.HOUR_OF_DAY)) {
|
||
|
|
// If hour is not set, set time to the midpoint of current day period, overwriting
|
||
|
|
// minutes if it's set.
|
||
|
|
double midPoint = ruleSet.getMidPointForDayPeriod(dayPeriod.value);
|
||
|
|
|
||
|
|
// Truncate midPoint toward zero to get the hour.
|
||
|
|
// Any leftover means it was a half-hour.
|
||
|
|
int midPointHour = (int) midPoint;
|
||
|
|
int midPointMinute = (midPoint - midPointHour) > 0 ? 30 : 0;
|
||
|
|
|
||
|
|
// No need to set am/pm because hour-of-day is set last therefore takes precedence.
|
||
|
|
cal.set(Calendar.HOUR_OF_DAY, midPointHour);
|
||
|
|
cal.set(Calendar.MINUTE, midPointMinute);
|
||
|
|
} else {
|
||
|
|
int hourOfDay;
|
||
|
|
|
||
|
|
if (cal.isSet(Calendar.HOUR_OF_DAY)) { // Hour is parsed in 24-hour format.
|
||
|
|
hourOfDay = cal.get(Calendar.HOUR_OF_DAY);
|
||
|
|
} else { // Hour is parsed in 12-hour format.
|
||
|
|
hourOfDay = cal.get(Calendar.HOUR);
|
||
|
|
// cal.get() turns 12 to 0 for 12-hour time; change 0 to 12
|
||
|
|
// so 0 unambiguously means a 24-hour time from above.
|
||
|
|
if (hourOfDay == 0) { hourOfDay = 12; }
|
||
|
|
}
|
||
|
|
assert(0 <= hourOfDay && hourOfDay <= 23);
|
||
|
|
|
||
|
|
|
||
|
|
// If hour-of-day is 0 or 13 thru 23 then input time in unambiguously in 24-hour format.
|
||
|
|
if (hourOfDay == 0 || (13 <= hourOfDay && hourOfDay <= 23)) {
|
||
|
|
// Make hour-of-day take precedence over (hour + am/pm) by setting it again.
|
||
|
|
cal.set(Calendar.HOUR_OF_DAY, hourOfDay);
|
||
|
|
} else {
|
||
|
|
// We have a 12-hour time and need to choose between am and pm.
|
||
|
|
// Behave as if dayPeriod spanned 6 hours each way from its center point.
|
||
|
|
// This will parse correctly for consistent time + period (e.g. 10 at night) as
|
||
|
|
// well as provide a reasonable recovery for inconsistent time + period (e.g.
|
||
|
|
// 9 in the afternoon).
|
||
|
|
|
||
|
|
// Assume current time is in the AM.
|
||
|
|
// - Change 12 back to 0 for easier handling of 12am.
|
||
|
|
// - Append minutes as fractional hours because e.g. 8:15 and 8:45 could be parsed
|
||
|
|
// into different half-days if center of dayPeriod is at 14:30.
|
||
|
|
// - cal.get(MINUTE) will return 0 if MINUTE is unset, which works.
|
||
|
|
if (hourOfDay == 12) { hourOfDay = 0; }
|
||
|
|
double currentHour = hourOfDay + cal.get(Calendar.MINUTE) / 60.0;
|
||
|
|
double midPointHour = ruleSet.getMidPointForDayPeriod(dayPeriod.value);
|
||
|
|
|
||
|
|
double hoursAheadMidPoint = currentHour - midPointHour;
|
||
|
|
|
||
|
|
// Assume current time is in the AM.
|
||
|
|
if (-6 <= hoursAheadMidPoint && hoursAheadMidPoint < 6) {
|
||
|
|
// Assumption holds; set time as such.
|
||
|
|
cal.set(Calendar.AM_PM, 0);
|
||
|
|
} else {
|
||
|
|
cal.set(Calendar.AM_PM, 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// At this point the fields of Calendar have been set. Calendar
|
||
|
|
// will fill in default values for missing fields when the time
|
||
|
|
// is computed.
|
||
|
|
|
||
|
|
parsePos.setIndex(pos);
|
||
|
|
|
||
|
|
// This part is a problem: When we call parsedDate.after, we compute the time.
|
||
|
|
// Take the date April 3 2004 at 2:30 am. When this is first set up, the year
|
||
|
|
// will be wrong if we're parsing a 2-digit year pattern. It will be 1904.
|
||
|
|
// April 3 1904 is a Sunday (unlike 2004) so it is the DST onset day. 2:30 am
|
||
|
|
// is therefore an "impossible" time, since the time goes from 1:59 to 3:00 am
|
||
|
|
// on that day. It is therefore parsed out to fields as 3:30 am. Then we
|
||
|
|
// add 100 years, and get April 3 2004 at 3:30 am. Note that April 3 2004 is
|
||
|
|
// a Saturday, so it can have a 2:30 am -- and it should. [LIU]
|
||
|
|
/*
|
||
|
|
Date parsedDate = cal.getTime();
|
||
|
|
if( ambiguousYear[0] && !parsedDate.after(getDefaultCenturyStart()) ) {
|
||
|
|
cal.add(Calendar.YEAR, 100);
|
||
|
|
parsedDate = cal.getTime();
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
// Because of the above condition, save off the fields in case we need to readjust.
|
||
|
|
// The procedure we use here is not particularly efficient, but there is no other
|
||
|
|
// way to do this given the API restrictions present in Calendar. We minimize
|
||
|
|
// inefficiency by only performing this computation when it might apply, that is,
|
||
|
|
// when the two-digit year is equal to the start year, and thus might fall at the
|
||
|
|
// front or the back of the default century. This only works because we adjust
|
||
|
|
// the year correctly to start with in other cases -- see subParse().
|
||
|
|
try {
|
||
|
|
TimeType tztype = tzTimeType.value;
|
||
|
|
if (ambiguousYear[0] || tztype != TimeType.UNKNOWN) {
|
||
|
|
// We need a copy of the fields, and we need to avoid triggering a call to
|
||
|
|
// complete(), which will recalculate the fields. Since we can't access
|
||
|
|
// the fields[] array in Calendar, we clone the entire object. This will
|
||
|
|
// stop working if Calendar.clone() is ever rewritten to call complete().
|
||
|
|
Calendar copy;
|
||
|
|
if (ambiguousYear[0]) { // the two-digit year == the default start year
|
||
|
|
copy = (Calendar)cal.clone();
|
||
|
|
Date parsedDate = copy.getTime();
|
||
|
|
if (parsedDate.before(getDefaultCenturyStart())) {
|
||
|
|
// We can't use add here because that does a complete() first.
|
||
|
|
cal.set(Calendar.YEAR, getDefaultCenturyStartYear() + 100);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (tztype != TimeType.UNKNOWN) {
|
||
|
|
copy = (Calendar)cal.clone();
|
||
|
|
TimeZone tz = copy.getTimeZone();
|
||
|
|
BasicTimeZone btz = null;
|
||
|
|
if (tz instanceof BasicTimeZone) {
|
||
|
|
btz = (BasicTimeZone)tz;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get local millis
|
||
|
|
copy.set(Calendar.ZONE_OFFSET, 0);
|
||
|
|
copy.set(Calendar.DST_OFFSET, 0);
|
||
|
|
long localMillis = copy.getTimeInMillis();
|
||
|
|
|
||
|
|
// Make sure parsed time zone type (Standard or Daylight)
|
||
|
|
// matches the rule used by the parsed time zone.
|
||
|
|
int[] offsets = new int[2];
|
||
|
|
if (btz != null) {
|
||
|
|
if (tztype == TimeType.STANDARD) {
|
||
|
|
btz.getOffsetFromLocal(localMillis,
|
||
|
|
LocalOption.STANDARD_FORMER, LocalOption.STANDARD_LATTER, offsets);
|
||
|
|
} else {
|
||
|
|
btz.getOffsetFromLocal(localMillis,
|
||
|
|
LocalOption.DAYLIGHT_FORMER, LocalOption.DAYLIGHT_LATTER, offsets);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// No good way to resolve ambiguous time at transition,
|
||
|
|
// but following code work in most case.
|
||
|
|
tz.getOffset(localMillis, true, offsets);
|
||
|
|
|
||
|
|
if (tztype == TimeType.STANDARD && offsets[1] != 0
|
||
|
|
|| tztype == TimeType.DAYLIGHT && offsets[1] == 0) {
|
||
|
|
// Roll back one day and try it again.
|
||
|
|
// Note: This code assumes 1. timezone transition only happens
|
||
|
|
// once within 24 hours at max
|
||
|
|
// 2. the difference of local offsets at the transition is
|
||
|
|
// less than 24 hours.
|
||
|
|
tz.getOffset(localMillis - (24*60*60*1000), true, offsets);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Now, compare the results with parsed type, either standard or
|
||
|
|
// daylight saving time
|
||
|
|
int resolvedSavings = offsets[1];
|
||
|
|
if (tztype == TimeType.STANDARD) {
|
||
|
|
if (offsets[1] != 0) {
|
||
|
|
// Override DST_OFFSET = 0 in the result calendar
|
||
|
|
resolvedSavings = 0;
|
||
|
|
}
|
||
|
|
} else { // tztype == TZTYPE_DST
|
||
|
|
if (offsets[1] == 0) {
|
||
|
|
if (btz != null) {
|
||
|
|
// This implementation resolves daylight saving time offset
|
||
|
|
// closest rule after the given time.
|
||
|
|
long baseTime = localMillis + offsets[0];
|
||
|
|
long time = baseTime;
|
||
|
|
long limit = baseTime + MAX_DAYLIGHT_DETECTION_RANGE;
|
||
|
|
TimeZoneTransition trs = null;
|
||
|
|
|
||
|
|
// Search for DST rule after the given time
|
||
|
|
while (time < limit) {
|
||
|
|
trs = btz.getNextTransition(time, false);
|
||
|
|
if (trs == null) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
resolvedSavings = trs.getTo().getDSTSavings();
|
||
|
|
if (resolvedSavings != 0) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
time = trs.getTime();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (resolvedSavings == 0) {
|
||
|
|
// If no DST rule after the given time was found, search for
|
||
|
|
// DST rule before.
|
||
|
|
time = baseTime;
|
||
|
|
limit = baseTime - MAX_DAYLIGHT_DETECTION_RANGE;
|
||
|
|
while (time > limit) {
|
||
|
|
trs = btz.getPreviousTransition(time, true);
|
||
|
|
if (trs == null) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
resolvedSavings = trs.getFrom().getDSTSavings();
|
||
|
|
if (resolvedSavings != 0) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
time = trs.getTime() - 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (resolvedSavings == 0) {
|
||
|
|
resolvedSavings = btz.getDSTSavings();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
resolvedSavings = tz.getDSTSavings();
|
||
|
|
}
|
||
|
|
if (resolvedSavings == 0) {
|
||
|
|
// Final fallback
|
||
|
|
resolvedSavings = millisPerHour;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
cal.set(Calendar.ZONE_OFFSET, offsets[0]);
|
||
|
|
cal.set(Calendar.DST_OFFSET, resolvedSavings);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// An IllegalArgumentException will be thrown by Calendar.getTime()
|
||
|
|
// if any fields are out of range, e.g., MONTH == 17.
|
||
|
|
catch (IllegalArgumentException e) {
|
||
|
|
parsePos.setErrorIndex(pos);
|
||
|
|
parsePos.setIndex(start);
|
||
|
|
if (backupTZ != null) {
|
||
|
|
calendar.setTimeZone(backupTZ);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
// Set the parsed result if local calendar is used
|
||
|
|
// instead of the input calendar
|
||
|
|
if (resultCal != null) {
|
||
|
|
resultCal.setTimeZone(cal.getTimeZone());
|
||
|
|
resultCal.setTimeInMillis(cal.getTimeInMillis());
|
||
|
|
}
|
||
|
|
// Restore the original time zone if required
|
||
|
|
if (backupTZ != null) {
|
||
|
|
calendar.setTimeZone(backupTZ);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Matches text (starting at pos) with patl. Returns the new pos, and sets complete[0]
|
||
|
|
* if it matched the entire text. Whitespace sequences are treated as singletons.
|
||
|
|
* <p>If isLenient and if we fail to match the first time, some special hacks are put into place.
|
||
|
|
* <ul><li>we are between date and time fields, then one or more whitespace characters
|
||
|
|
* in the text are accepted instead.</li>
|
||
|
|
* <ul><li>we are after a non-numeric field, and the text starts with a ".", we skip it.</li>
|
||
|
|
* </ul>
|
||
|
|
*/
|
||
|
|
private int matchLiteral(String text, int pos, Object[] items, int itemIndex, boolean[] complete) {
|
||
|
|
int originalPos = pos;
|
||
|
|
String patternLiteral = (String)items[itemIndex];
|
||
|
|
int plen = patternLiteral.length();
|
||
|
|
int tlen = text.length();
|
||
|
|
int idx = 0;
|
||
|
|
while (idx < plen && pos < tlen) {
|
||
|
|
char pch = patternLiteral.charAt(idx);
|
||
|
|
char ich = text.charAt(pos);
|
||
|
|
if ((PatternProps.isWhiteSpace(pch) || UCharacter.isUWhiteSpace(pch))
|
||
|
|
&& (PatternProps.isWhiteSpace(ich) || UCharacter.isUWhiteSpace(ich))) {
|
||
|
|
// White space characters found in both patten and input.
|
||
|
|
// Skip contiguous white spaces.
|
||
|
|
while ((idx + 1) < plen &&
|
||
|
|
(PatternProps.isWhiteSpace(patternLiteral.charAt(idx + 1)) ||
|
||
|
|
UCharacter.isUWhiteSpace(patternLiteral.charAt(idx + 1)))) {
|
||
|
|
++idx;
|
||
|
|
}
|
||
|
|
while ((pos + 1) < tlen &&
|
||
|
|
(PatternProps.isWhiteSpace(text.charAt(pos + 1)) ||
|
||
|
|
UCharacter.isUWhiteSpace(text.charAt(pos + 1)))) {
|
||
|
|
++pos;
|
||
|
|
}
|
||
|
|
} else if (pch != ich) {
|
||
|
|
if (ich == '.' && pos == originalPos && 0 < itemIndex && getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_ALLOW_WHITESPACE)) {
|
||
|
|
Object before = items[itemIndex-1];
|
||
|
|
if (before instanceof PatternItem) {
|
||
|
|
boolean isNumeric = ((PatternItem) before).isNumeric;
|
||
|
|
if (!isNumeric) {
|
||
|
|
++pos; // just update pos
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if ((pch == ' ' || pch == '.') && getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_ALLOW_WHITESPACE)) {
|
||
|
|
++idx;
|
||
|
|
continue;
|
||
|
|
} else if (pos != originalPos && getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_PARTIAL_LITERAL_MATCH)) {
|
||
|
|
++idx;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
++idx;
|
||
|
|
++pos;
|
||
|
|
}
|
||
|
|
complete[0] = idx == plen;
|
||
|
|
if (complete[0] == false && getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_ALLOW_WHITESPACE) && 0 < itemIndex && itemIndex < items.length - 1) {
|
||
|
|
// If fully lenient, accept " "* for any text between a date and a time field
|
||
|
|
// We don't go more lenient, because we don't want to accept "12/31" for "12:31".
|
||
|
|
// People may be trying to parse for a date, then for a time.
|
||
|
|
if (originalPos < tlen) {
|
||
|
|
Object before = items[itemIndex-1];
|
||
|
|
Object after = items[itemIndex+1];
|
||
|
|
if (before instanceof PatternItem && after instanceof PatternItem) {
|
||
|
|
char beforeType = ((PatternItem) before).type;
|
||
|
|
char afterType = ((PatternItem) after).type;
|
||
|
|
if (DATE_PATTERN_TYPE.contains(beforeType) != DATE_PATTERN_TYPE.contains(afterType)) {
|
||
|
|
int newPos = originalPos;
|
||
|
|
while (newPos < tlen) {
|
||
|
|
char ich = text.charAt(newPos);
|
||
|
|
if (!PatternProps.isWhiteSpace(ich)) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
++newPos;
|
||
|
|
}
|
||
|
|
complete[0] = newPos > originalPos;
|
||
|
|
pos = newPos;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return pos;
|
||
|
|
}
|
||
|
|
|
||
|
|
static final UnicodeSet DATE_PATTERN_TYPE = new UnicodeSet("[GyYuUQqMLlwWd]").freeze();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Attempt to match the text at a given position against two arrays of
|
||
|
|
* month symbol 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. As a side
|
||
|
|
* effect, the given field of <code>cal</code> is set to the index
|
||
|
|
* of the best match, if there is one.
|
||
|
|
* @param text the time text being parsed.
|
||
|
|
* @param start where to start parsing.
|
||
|
|
* @param wideData the string array of wide month symbols
|
||
|
|
* @param shortData the string array of short month symbols
|
||
|
|
* @param cal
|
||
|
|
* @return the new start position if matching succeeded; a negative
|
||
|
|
* number indicating matching failure, otherwise. As a side effect,
|
||
|
|
* sets the <code>cal</code> field <code>field</code> to the index
|
||
|
|
* of the best match, if matching succeeded.
|
||
|
|
* @deprecated This API is ICU internal only.
|
||
|
|
* Does not handle monthPattern.
|
||
|
|
* field is always Calendar.MONTH
|
||
|
|
* @hide draft / provisional / internal are hidden on Android
|
||
|
|
*/
|
||
|
|
@Deprecated
|
||
|
|
private int matchAlphaMonthStrings(String text, int start, String[] wideData, String[] shortData, Calendar cal)
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
int bestMatchLength = 0, bestMatch = -1;
|
||
|
|
|
||
|
|
for (i = 0; i<wideData.length; ++i)
|
||
|
|
{
|
||
|
|
int length = wideData[i].length();
|
||
|
|
int matchLength = 0;
|
||
|
|
// Always compare if we have no match yet; otherwise only compare
|
||
|
|
// against potentially better matches (longer strings).
|
||
|
|
if (length > bestMatchLength &&
|
||
|
|
(matchLength = regionMatchesWithOptionalDot(text, start, wideData[i], length)) >= 0)
|
||
|
|
{
|
||
|
|
bestMatch = i;
|
||
|
|
bestMatchLength = matchLength;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (i = 0; i<shortData.length; ++i)
|
||
|
|
{
|
||
|
|
int length = shortData[i].length();
|
||
|
|
int matchLength = 0;
|
||
|
|
// Always compare if we have no match yet; otherwise only compare
|
||
|
|
// against potentially better matches (longer strings).
|
||
|
|
if (length > bestMatchLength &&
|
||
|
|
(matchLength = regionMatchesWithOptionalDot(text, start, shortData[i], length)) >= 0)
|
||
|
|
{
|
||
|
|
bestMatch = i;
|
||
|
|
bestMatchLength = matchLength;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (bestMatch >= 0)
|
||
|
|
{
|
||
|
|
cal.set(Calendar.MONTH, bestMatch);
|
||
|
|
return start + bestMatchLength;
|
||
|
|
}
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Attempt 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. As a side
|
||
|
|
* effect, the given field of <code>cal</code> is set to the index
|
||
|
|
* of the best match, if there is one.
|
||
|
|
* @param text the time text being parsed.
|
||
|
|
* @param start where to start parsing.
|
||
|
|
* @param field the date field being parsed.
|
||
|
|
* @param data the string array to parsed.
|
||
|
|
* @param cal
|
||
|
|
* @return the new start position if matching succeeded; a negative
|
||
|
|
* number indicating matching failure, otherwise. As a side effect,
|
||
|
|
* sets the <code>cal</code> field <code>field</code> to the index
|
||
|
|
* of the best match, if matching succeeded.
|
||
|
|
*/
|
||
|
|
protected int matchString(String text, int start, int field, String[] data, Calendar cal)
|
||
|
|
{
|
||
|
|
return matchString(text, start, field, data, null, cal);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Attempt 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. As a side
|
||
|
|
* effect, the given field of <code>cal</code> is set to the index
|
||
|
|
* of the best match, if there is one.
|
||
|
|
* @param text the time text being parsed.
|
||
|
|
* @param start where to start parsing.
|
||
|
|
* @param field the date field being parsed.
|
||
|
|
* @param data the string array to parsed.
|
||
|
|
* @param monthPattern leap month pattern, or null if none.
|
||
|
|
* @param cal
|
||
|
|
* @return the new start position if matching succeeded; a negative
|
||
|
|
* number indicating matching failure, otherwise. As a side effect,
|
||
|
|
* sets the <code>cal</code> field <code>field</code> to the index
|
||
|
|
* of the best match, if matching succeeded.
|
||
|
|
* @deprecated This API is ICU internal only.
|
||
|
|
* @hide draft / provisional / internal are hidden on Android
|
||
|
|
*/
|
||
|
|
@Deprecated
|
||
|
|
private int matchString(String text, int start, int field, String[] data, String monthPattern, Calendar cal)
|
||
|
|
{
|
||
|
|
int i = 0;
|
||
|
|
int count = data.length;
|
||
|
|
|
||
|
|
if (field == Calendar.DAY_OF_WEEK) i = 1;
|
||
|
|
|
||
|
|
// 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;
|
||
|
|
int isLeapMonth = 0;
|
||
|
|
int matchLength = 0;
|
||
|
|
|
||
|
|
for (; 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 &&
|
||
|
|
(matchLength = regionMatchesWithOptionalDot(text, start, data[i], length)) >= 0)
|
||
|
|
{
|
||
|
|
bestMatch = i;
|
||
|
|
bestMatchLength = matchLength;
|
||
|
|
isLeapMonth = 0;
|
||
|
|
}
|
||
|
|
if (monthPattern != null) {
|
||
|
|
String leapMonthName = SimpleFormatterImpl.formatRawPattern(
|
||
|
|
monthPattern, 1, 1, data[i]);
|
||
|
|
length = leapMonthName.length();
|
||
|
|
if (length > bestMatchLength &&
|
||
|
|
(matchLength = regionMatchesWithOptionalDot(text, start, leapMonthName, length)) >= 0)
|
||
|
|
{
|
||
|
|
bestMatch = i;
|
||
|
|
bestMatchLength = matchLength;
|
||
|
|
isLeapMonth = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (bestMatch >= 0)
|
||
|
|
{
|
||
|
|
if (field >= 0) {
|
||
|
|
if (field == Calendar.YEAR) {
|
||
|
|
bestMatch++; // only get here for cyclic year names, which match 1-based years 1-60
|
||
|
|
}
|
||
|
|
cal.set(field, bestMatch);
|
||
|
|
if (monthPattern != null) {
|
||
|
|
cal.set(Calendar.IS_LEAP_MONTH, isLeapMonth);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return start + bestMatchLength;
|
||
|
|
}
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
|
||
|
|
private int regionMatchesWithOptionalDot(String text, int start, String data, int length) {
|
||
|
|
boolean matches = text.regionMatches(true, start, data, 0, length);
|
||
|
|
if (matches) {
|
||
|
|
return length;
|
||
|
|
}
|
||
|
|
if (data.length() > 0 && data.charAt(data.length()-1) == '.') {
|
||
|
|
if (text.regionMatches(true, start, data, 0, length-1)) {
|
||
|
|
return length - 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Attempt to match the text at a given position against an array of quarter
|
||
|
|
* 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. As a side
|
||
|
|
* effect, the given field of <code>cal</code> is set to the index
|
||
|
|
* of the best match, if there is one.
|
||
|
|
* @param text the time text being parsed.
|
||
|
|
* @param start where to start parsing.
|
||
|
|
* @param field the date field being parsed.
|
||
|
|
* @param data the string array to parsed.
|
||
|
|
* @return the new start position if matching succeeded; a negative
|
||
|
|
* number indicating matching failure, otherwise. As a side effect,
|
||
|
|
* sets the <code>cal</code> field <code>field</code> to the index
|
||
|
|
* of the best match, if matching succeeded.
|
||
|
|
*/
|
||
|
|
protected int matchQuarterString(String text, int start, int field, String[] data, Calendar cal)
|
||
|
|
{
|
||
|
|
int i = 0;
|
||
|
|
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;
|
||
|
|
int matchLength = 0;
|
||
|
|
for (; 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 &&
|
||
|
|
(matchLength = regionMatchesWithOptionalDot(text, start, data[i], length)) >= 0) {
|
||
|
|
|
||
|
|
bestMatch = i;
|
||
|
|
bestMatchLength = matchLength;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (bestMatch >= 0) {
|
||
|
|
cal.set(field, bestMatch * 3);
|
||
|
|
return start + bestMatchLength;
|
||
|
|
}
|
||
|
|
|
||
|
|
return -start;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Similar to matchQuarterString but customized for day periods.
|
||
|
|
*/
|
||
|
|
private int matchDayPeriodString(String text, int start, String[] data, int dataLength,
|
||
|
|
Output<DayPeriodRules.DayPeriod> dayPeriod)
|
||
|
|
{
|
||
|
|
int bestMatchLength = 0, bestMatch = -1;
|
||
|
|
int matchLength = 0;
|
||
|
|
for (int i = 0; i < dataLength; ++i) {
|
||
|
|
// Only try matching if the string exists.
|
||
|
|
if (data[i] != null) {
|
||
|
|
int length = data[i].length();
|
||
|
|
if (length > bestMatchLength &&
|
||
|
|
(matchLength = regionMatchesWithOptionalDot(text, start, data[i], length)) >= 0) {
|
||
|
|
bestMatch = i;
|
||
|
|
bestMatchLength = matchLength;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (bestMatch >= 0) {
|
||
|
|
dayPeriod.value = DayPeriodRules.DayPeriod.VALUES[bestMatch];
|
||
|
|
return start + bestMatchLength;
|
||
|
|
}
|
||
|
|
|
||
|
|
return -start;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Protected method that converts one field of the input string into a
|
||
|
|
* numeric field value in <code>cal</code>. Returns -start (for
|
||
|
|
* ParsePosition) if failed. Subclasses may override this method to
|
||
|
|
* modify or add parsing capabilities.
|
||
|
|
* @param text the time text to be parsed.
|
||
|
|
* @param start where to start parsing.
|
||
|
|
* @param ch the pattern character for the date field text to be parsed.
|
||
|
|
* @param count the count of a pattern character.
|
||
|
|
* @param obeyCount if true, then the next field directly abuts this one,
|
||
|
|
* and we should use the count to know when to stop parsing.
|
||
|
|
* @param ambiguousYear return parameter; upon return, if ambiguousYear[0]
|
||
|
|
* is true, then a two-digit year was parsed and may need to be readjusted.
|
||
|
|
* @param cal
|
||
|
|
* @return the new start position if matching succeeded; a negative
|
||
|
|
* number indicating matching failure, otherwise. As a side effect,
|
||
|
|
* set the appropriate field of <code>cal</code> with the parsed
|
||
|
|
* value.
|
||
|
|
*/
|
||
|
|
protected int subParse(String text, int start, char ch, int count,
|
||
|
|
boolean obeyCount, boolean allowNegative,
|
||
|
|
boolean[] ambiguousYear, Calendar cal)
|
||
|
|
{
|
||
|
|
return subParse(text, start, ch, count, obeyCount, allowNegative, ambiguousYear, cal, null, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Overloading to provide default argument (null) for day period.
|
||
|
|
*/
|
||
|
|
private int subParse(String text, int start, char ch, int count,
|
||
|
|
boolean obeyCount, boolean allowNegative,
|
||
|
|
boolean[] ambiguousYear, Calendar cal,
|
||
|
|
MessageFormat numericLeapMonthFormatter, Output<TimeType> tzTimeType) {
|
||
|
|
return subParse(text, start, ch, count, obeyCount, allowNegative, ambiguousYear, cal, null, null, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Protected method that converts one field of the input string into a
|
||
|
|
* numeric field value in <code>cal</code>. Returns -start (for
|
||
|
|
* ParsePosition) if failed. Subclasses may override this method to
|
||
|
|
* modify or add parsing capabilities.
|
||
|
|
* @param text the time text to be parsed.
|
||
|
|
* @param start where to start parsing.
|
||
|
|
* @param ch the pattern character for the date field text to be parsed.
|
||
|
|
* @param count the count of a pattern character.
|
||
|
|
* @param obeyCount if true, then the next field directly abuts this one,
|
||
|
|
* and we should use the count to know when to stop parsing.
|
||
|
|
* @param ambiguousYear return parameter; upon return, if ambiguousYear[0]
|
||
|
|
* is true, then a two-digit year was parsed and may need to be readjusted.
|
||
|
|
* @param cal
|
||
|
|
* @param numericLeapMonthFormatter if non-null, used to parse numeric leap months.
|
||
|
|
* @param tzTimeType the type of parsed time zone - standard, daylight or unknown (output).
|
||
|
|
* This parameter can be null if caller does not need the information.
|
||
|
|
* @return the new start position if matching succeeded; a negative
|
||
|
|
* number indicating matching failure, otherwise. As a side effect,
|
||
|
|
* set the appropriate field of <code>cal</code> with the parsed
|
||
|
|
* value.
|
||
|
|
* @deprecated This API is ICU internal only.
|
||
|
|
* @hide draft / provisional / internal are hidden on Android
|
||
|
|
*/
|
||
|
|
@Deprecated
|
||
|
|
@SuppressWarnings("fallthrough")
|
||
|
|
private int subParse(String text, int start, char ch, int count,
|
||
|
|
boolean obeyCount, boolean allowNegative,
|
||
|
|
boolean[] ambiguousYear, Calendar cal,
|
||
|
|
MessageFormat numericLeapMonthFormatter, Output<TimeType> tzTimeType,
|
||
|
|
Output<DayPeriodRules.DayPeriod> dayPeriod)
|
||
|
|
{
|
||
|
|
Number number = null;
|
||
|
|
NumberFormat currentNumberFormat = null;
|
||
|
|
int value = 0;
|
||
|
|
int i;
|
||
|
|
ParsePosition pos = new ParsePosition(0);
|
||
|
|
|
||
|
|
int patternCharIndex = getIndexFromChar(ch);
|
||
|
|
if (patternCharIndex == -1) {
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
|
||
|
|
currentNumberFormat = getNumberFormat(ch);
|
||
|
|
|
||
|
|
int field = PATTERN_INDEX_TO_CALENDAR_FIELD[patternCharIndex]; // -1 if irrelevant
|
||
|
|
|
||
|
|
if (numericLeapMonthFormatter != null) {
|
||
|
|
numericLeapMonthFormatter.setFormatByArgumentIndex(0, currentNumberFormat);
|
||
|
|
}
|
||
|
|
boolean isChineseCalendar = ( cal.getType().equals("chinese") || cal.getType().equals("dangi") );
|
||
|
|
|
||
|
|
// If there are any spaces here, skip over them. If we hit the end
|
||
|
|
// of the string, then fail.
|
||
|
|
for (;;) {
|
||
|
|
if (start >= text.length()) {
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
int c = UTF16.charAt(text, start);
|
||
|
|
// Changed the following from || to &&, as in ICU4C; needed to skip NBSP, NNBSP.
|
||
|
|
// Only UWhiteSpace includes \u00A0\u202F\u2009\u3000...; only PatternProps.isWhiteSpace includes \u200E\u200F
|
||
|
|
if (!UCharacter.isUWhiteSpace(c) && !PatternProps.isWhiteSpace(c)) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
start += UTF16.getCharCount(c);
|
||
|
|
}
|
||
|
|
pos.setIndex(start);
|
||
|
|
|
||
|
|
// We handle a few special cases here where we need to parse
|
||
|
|
// a number value. We handle further, more generic cases below. We need
|
||
|
|
// to handle some of them here because some fields require extra processing on
|
||
|
|
// the parsed value.
|
||
|
|
if (patternCharIndex == 4 /*'k' HOUR_OF_DAY1_FIELD*/ ||
|
||
|
|
patternCharIndex == 15 /*'h' HOUR1_FIELD*/ ||
|
||
|
|
(patternCharIndex == 2 /*'M' MONTH_FIELD*/ && count <= 2) ||
|
||
|
|
patternCharIndex == 26 /*'L' STAND_ALONE_MONTH*/ ||
|
||
|
|
patternCharIndex == 19 /*'e' DOW_LOCAL*/ ||
|
||
|
|
patternCharIndex == 25 /*'c' STAND_ALONE_DAY_OF_WEEK*/ ||
|
||
|
|
patternCharIndex == 1 /*'y' YEAR */ || patternCharIndex == 18 /*'Y' YEAR_WOY */ ||
|
||
|
|
patternCharIndex == 30 /*'U' YEAR_NAME_FIELD, falls back to numeric */ ||
|
||
|
|
(patternCharIndex == 0 /*'G' ERA */ && isChineseCalendar) ||
|
||
|
|
patternCharIndex == 27 /* 'Q' - QUARTER*/ ||
|
||
|
|
patternCharIndex == 28 /* 'q' - STANDALONE QUARTER*/ ||
|
||
|
|
patternCharIndex == 8 /*'S' FRACTIONAL_SECOND */ )
|
||
|
|
{
|
||
|
|
// It would be good to unify this with the obeyCount logic below,
|
||
|
|
// but that's going to be difficult.
|
||
|
|
|
||
|
|
boolean parsedNumericLeapMonth = false;
|
||
|
|
if (numericLeapMonthFormatter != null && (patternCharIndex == 2 || patternCharIndex == 26)) {
|
||
|
|
// First see if we can parse month number with leap month pattern
|
||
|
|
Object[] args = numericLeapMonthFormatter.parse(text, pos);
|
||
|
|
if (args != null && pos.getIndex() > start && (args[0] instanceof Number)) {
|
||
|
|
parsedNumericLeapMonth = true;
|
||
|
|
number = (Number)args[0];
|
||
|
|
cal.set(Calendar.IS_LEAP_MONTH, 1);
|
||
|
|
} else {
|
||
|
|
pos.setIndex(start);
|
||
|
|
cal.set(Calendar.IS_LEAP_MONTH, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!parsedNumericLeapMonth) {
|
||
|
|
if (obeyCount) {
|
||
|
|
if ((start+count) > text.length()) {
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
number = parseInt(text, count, pos, allowNegative,currentNumberFormat);
|
||
|
|
} else {
|
||
|
|
number = parseInt(text, pos, allowNegative,currentNumberFormat);
|
||
|
|
}
|
||
|
|
if (number == null && !allowNumericFallback(patternCharIndex)) {
|
||
|
|
// only return if pattern is NOT one that allows numeric fallback
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (number != null) {
|
||
|
|
value = number.intValue();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
switch (patternCharIndex)
|
||
|
|
{
|
||
|
|
case 0: // 'G' - ERA
|
||
|
|
if ( isChineseCalendar ) {
|
||
|
|
// Numeric era handling moved from ChineseDateFormat,
|
||
|
|
// If we didn't have a number, already returned -start above
|
||
|
|
cal.set(Calendar.ERA, value);
|
||
|
|
return pos.getIndex();
|
||
|
|
}
|
||
|
|
int ps = 0;
|
||
|
|
if (count == 5) {
|
||
|
|
ps = matchString(text, start, Calendar.ERA, formatData.narrowEras, null, cal);
|
||
|
|
} else if (count == 4) {
|
||
|
|
ps = matchString(text, start, Calendar.ERA, formatData.eraNames, null, cal);
|
||
|
|
} else {
|
||
|
|
ps = matchString(text, start, Calendar.ERA, formatData.eras, null, cal);
|
||
|
|
}
|
||
|
|
|
||
|
|
// check return position, if it equals -start, then matchString error
|
||
|
|
// special case the return code so we don't necessarily fail out until we
|
||
|
|
// verify no year information also
|
||
|
|
if (ps == ~start)
|
||
|
|
ps = ISOSpecialEra;
|
||
|
|
|
||
|
|
return ps;
|
||
|
|
|
||
|
|
case 1: // 'y' - YEAR
|
||
|
|
case 18: // 'Y' - YEAR_WOY
|
||
|
|
// If there are 3 or more YEAR pattern characters, this indicates
|
||
|
|
// that the year value is to be treated literally, without any
|
||
|
|
// two-digit year adjustments (e.g., from "01" to 2001). Otherwise
|
||
|
|
// we made adjustments to place the 2-digit year in the proper
|
||
|
|
// century, for parsed strings from "00" to "99". Any other string
|
||
|
|
// is treated literally: "2250", "-1", "1", "002".
|
||
|
|
/* 'yy' is the only special case, 'y' is interpreted as number. [Richard/GCL]*/
|
||
|
|
/* Skip this for Chinese calendar, moved from ChineseDateFormat */
|
||
|
|
if ( override != null && (override.compareTo("hebr") == 0 || override.indexOf("y=hebr") >= 0) && value < 1000 ) {
|
||
|
|
value += HEBREW_CAL_CUR_MILLENIUM_START_YEAR;
|
||
|
|
} else if (count == 2 && countDigits(text, start, pos.getIndex()) == 2 && cal.haveDefaultCentury()) {
|
||
|
|
// 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.
|
||
|
|
int ambiguousTwoDigitYear = getDefaultCenturyStartYear() % 100;
|
||
|
|
ambiguousYear[0] = value == ambiguousTwoDigitYear;
|
||
|
|
value += (getDefaultCenturyStartYear()/100)*100 +
|
||
|
|
(value < ambiguousTwoDigitYear ? 100 : 0);
|
||
|
|
}
|
||
|
|
cal.set(field, value);
|
||
|
|
|
||
|
|
// Delayed checking for adjustment of Hebrew month numbers in non-leap years.
|
||
|
|
if (DelayedHebrewMonthCheck) {
|
||
|
|
if (!HebrewCalendar.isLeapYear(value)) {
|
||
|
|
cal.add(Calendar.MONTH,1);
|
||
|
|
}
|
||
|
|
DelayedHebrewMonthCheck = false;
|
||
|
|
}
|
||
|
|
return pos.getIndex();
|
||
|
|
case 30: // 'U' - YEAR_NAME_FIELD
|
||
|
|
if (formatData.shortYearNames != null) {
|
||
|
|
int newStart = matchString(text, start, Calendar.YEAR, formatData.shortYearNames, null, cal);
|
||
|
|
if (newStart > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ( number != null && (getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_ALLOW_NUMERIC) || formatData.shortYearNames == null || value > formatData.shortYearNames.length) ) {
|
||
|
|
cal.set(Calendar.YEAR, value);
|
||
|
|
return pos.getIndex();
|
||
|
|
}
|
||
|
|
return ~start;
|
||
|
|
case 2: // 'M' - MONTH
|
||
|
|
case 26: // 'L' - STAND_ALONE_MONTH
|
||
|
|
if (count <= 2 || (number != null && getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_ALLOW_NUMERIC))) {
|
||
|
|
// i.e., M/MM, L/LL or lenient & have a number
|
||
|
|
// Don't want to parse the month if it is a string
|
||
|
|
// while pattern uses numeric style: M/MM, L/LL.
|
||
|
|
// [We computed 'value' above.]
|
||
|
|
cal.set(Calendar.MONTH, value - 1);
|
||
|
|
// When parsing month numbers from the Hebrew Calendar, we might need
|
||
|
|
// to adjust the month depending on whether or not it was a leap year.
|
||
|
|
// We may or may not yet know what year it is, so might have to delay
|
||
|
|
// checking until the year is parsed.
|
||
|
|
if (cal.getType().equals("hebrew") && value >= 6) {
|
||
|
|
if (cal.isSet(Calendar.YEAR)) {
|
||
|
|
if (!HebrewCalendar.isLeapYear(cal.get(Calendar.YEAR))) {
|
||
|
|
cal.set(Calendar.MONTH, value);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
DelayedHebrewMonthCheck = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return pos.getIndex();
|
||
|
|
} else {
|
||
|
|
// count >= 3 // i.e., MMM/MMMM or LLL/LLLL
|
||
|
|
// Want to be able to parse both short and long forms.
|
||
|
|
boolean haveMonthPat = (formatData.leapMonthPatterns != null && formatData.leapMonthPatterns.length >= DateFormatSymbols.DT_MONTH_PATTERN_COUNT);
|
||
|
|
// Try count == 4 first:, unless we're strict
|
||
|
|
int newStart = 0;
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH)&& count>=3 && count <=4 && !haveMonthPat) {
|
||
|
|
newStart = (patternCharIndex == 2)?
|
||
|
|
matchAlphaMonthStrings(text, start, formatData.months, formatData.shortMonths, cal):
|
||
|
|
matchAlphaMonthStrings(text, start, formatData.standaloneMonths, formatData.standaloneShortMonths, cal);
|
||
|
|
if (newStart > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 4) {
|
||
|
|
newStart = (patternCharIndex == 2)?
|
||
|
|
matchString(text, start, Calendar.MONTH, formatData.months,
|
||
|
|
(haveMonthPat)? formatData.leapMonthPatterns[DateFormatSymbols.DT_LEAP_MONTH_PATTERN_FORMAT_WIDE]: null, cal):
|
||
|
|
matchString(text, start, Calendar.MONTH, formatData.standaloneMonths,
|
||
|
|
(haveMonthPat)? formatData.leapMonthPatterns[DateFormatSymbols.DT_LEAP_MONTH_PATTERN_STANDALONE_WIDE]: null, cal);
|
||
|
|
if (newStart > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// count == 4 failed, now try count == 3
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 3) {
|
||
|
|
return (patternCharIndex == 2)?
|
||
|
|
matchString(text, start, Calendar.MONTH, formatData.shortMonths,
|
||
|
|
(haveMonthPat)? formatData.leapMonthPatterns[DateFormatSymbols.DT_LEAP_MONTH_PATTERN_FORMAT_ABBREV]: null, cal):
|
||
|
|
matchString(text, start, Calendar.MONTH, formatData.standaloneShortMonths,
|
||
|
|
(haveMonthPat)? formatData.leapMonthPatterns[DateFormatSymbols.DT_LEAP_MONTH_PATTERN_STANDALONE_ABBREV]: null, cal);
|
||
|
|
}
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
case 4: // 'k' - HOUR_OF_DAY (1..24)
|
||
|
|
// [We computed 'value' above.]
|
||
|
|
if (value == cal.getMaximum(Calendar.HOUR_OF_DAY)+1) {
|
||
|
|
value = 0;
|
||
|
|
}
|
||
|
|
cal.set(Calendar.HOUR_OF_DAY, value);
|
||
|
|
return pos.getIndex();
|
||
|
|
case 8: // 'S' - FRACTIONAL_SECOND
|
||
|
|
// Fractional seconds left-justify
|
||
|
|
i = countDigits(text, start, pos.getIndex());
|
||
|
|
if (i < 3) {
|
||
|
|
while (i < 3) {
|
||
|
|
value *= 10;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
int a = 1;
|
||
|
|
while (i > 3) {
|
||
|
|
a *= 10;
|
||
|
|
i--;
|
||
|
|
}
|
||
|
|
value /= a;
|
||
|
|
}
|
||
|
|
cal.set(Calendar.MILLISECOND, value);
|
||
|
|
return pos.getIndex();
|
||
|
|
case 19: // 'e' - DOW_LOCAL
|
||
|
|
if(count <= 2 || (number != null && (getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_ALLOW_NUMERIC))) ) {
|
||
|
|
// i.e. e/ee or lenient and have a number
|
||
|
|
cal.set(field, value);
|
||
|
|
return pos.getIndex();
|
||
|
|
}
|
||
|
|
// else for eee-eeeeee, fall through to EEE-EEEEEE handling
|
||
|
|
//$FALL-THROUGH$
|
||
|
|
case 9: { // 'E' - DAY_OF_WEEK
|
||
|
|
// Want to be able to parse at least wide, abbrev, short, and narrow forms.
|
||
|
|
int newStart = 0;
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 4) {
|
||
|
|
if ((newStart = matchString(text, start, Calendar.DAY_OF_WEEK, formatData.weekdays, null, cal)) > 0) { // try EEEE wide
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 3) {
|
||
|
|
if ((newStart = matchString(text, start, Calendar.DAY_OF_WEEK, formatData.shortWeekdays, null, cal)) > 0) { // try EEE abbrev
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 6) {
|
||
|
|
if (formatData.shorterWeekdays != null) {
|
||
|
|
if((newStart = matchString(text, start, Calendar.DAY_OF_WEEK, formatData.shorterWeekdays, null, cal)) > 0) { // try EEEEEE short
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 5) {
|
||
|
|
if (formatData.narrowWeekdays != null) {
|
||
|
|
if((newStart = matchString(text, start, Calendar.DAY_OF_WEEK, formatData.narrowWeekdays, null, cal)) > 0) { // try EEEEE narrow
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
case 25: { // 'c' - STAND_ALONE_DAY_OF_WEEK
|
||
|
|
if(count == 1 || (number != null && (getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_ALLOW_NUMERIC))) ) {
|
||
|
|
// i.e. c or lenient and have a number
|
||
|
|
cal.set(field, value);
|
||
|
|
return pos.getIndex();
|
||
|
|
}
|
||
|
|
// Want to be able to parse at least wide, abbrev, short forms.
|
||
|
|
int newStart = 0;
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 4) {
|
||
|
|
if ((newStart = matchString(text, start, Calendar.DAY_OF_WEEK, formatData.standaloneWeekdays, null, cal)) > 0) { // try cccc wide
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 3) {
|
||
|
|
if ((newStart = matchString(text, start, Calendar.DAY_OF_WEEK, formatData.standaloneShortWeekdays, null, cal)) > 0) { // try ccc abbrev
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 6) {
|
||
|
|
if (formatData.standaloneShorterWeekdays != null) {
|
||
|
|
return matchString(text, start, Calendar.DAY_OF_WEEK, formatData.standaloneShorterWeekdays, null, cal); // try cccccc short
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
case 14: { // 'a' - AM_PM
|
||
|
|
// Optionally try both wide/abbrev and narrow forms.
|
||
|
|
// formatData.ampmsNarrow may be null when deserializing DateFormatSymbolsfrom old version,
|
||
|
|
// in which case our only option is wide form
|
||
|
|
int newStart = 0;
|
||
|
|
// try wide/abbrev a-aaaa
|
||
|
|
if(formatData.ampmsNarrow == null || count < 5 || getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH)) {
|
||
|
|
if ((newStart = matchString(text, start, Calendar.AM_PM, formatData.ampms, null, cal)) > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// try narrow aaaaa
|
||
|
|
if(formatData.ampmsNarrow != null && (count >= 5 || getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH))) {
|
||
|
|
if ((newStart = matchString(text, start, Calendar.AM_PM, formatData.ampmsNarrow, null, cal)) > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// no matches for given options
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
case 15: // 'h' - HOUR (1..12)
|
||
|
|
// [We computed 'value' above.]
|
||
|
|
if (value == cal.getLeastMaximum(Calendar.HOUR)+1) {
|
||
|
|
value = 0;
|
||
|
|
}
|
||
|
|
cal.set(Calendar.HOUR, value);
|
||
|
|
return pos.getIndex();
|
||
|
|
case 17: // 'z' - ZONE_OFFSET
|
||
|
|
{
|
||
|
|
Style style = (count < 4) ? Style.SPECIFIC_SHORT : Style.SPECIFIC_LONG;
|
||
|
|
TimeZone tz = tzFormat().parse(style, text, pos, tzTimeType);
|
||
|
|
if (tz != null) {
|
||
|
|
cal.setTimeZone(tz);
|
||
|
|
return pos.getIndex();
|
||
|
|
}
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
case 23: // 'Z' - TIMEZONE_RFC
|
||
|
|
{
|
||
|
|
Style style = (count < 4) ? Style.ISO_BASIC_LOCAL_FULL : ((count == 5) ? Style.ISO_EXTENDED_FULL : Style.LOCALIZED_GMT);
|
||
|
|
TimeZone tz = tzFormat().parse(style, text, pos, tzTimeType);
|
||
|
|
if (tz != null) {
|
||
|
|
cal.setTimeZone(tz);
|
||
|
|
return pos.getIndex();
|
||
|
|
}
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
case 24: // 'v' - TIMEZONE_GENERIC
|
||
|
|
{
|
||
|
|
// Note: 'v' only supports count 1 and 4
|
||
|
|
Style style = (count < 4) ? Style.GENERIC_SHORT : Style.GENERIC_LONG;
|
||
|
|
TimeZone tz = tzFormat().parse(style, text, pos, tzTimeType);
|
||
|
|
if (tz != null) {
|
||
|
|
cal.setTimeZone(tz);
|
||
|
|
return pos.getIndex();
|
||
|
|
}
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
case 29: // 'V' - TIMEZONE_SPECIAL
|
||
|
|
{
|
||
|
|
Style style = null;
|
||
|
|
switch (count) {
|
||
|
|
case 1:
|
||
|
|
style = Style.ZONE_ID_SHORT;
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
style = Style.ZONE_ID;
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
style = Style.EXEMPLAR_LOCATION;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
style = Style.GENERIC_LOCATION;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
TimeZone tz = tzFormat().parse(style, text, pos, tzTimeType);
|
||
|
|
if (tz != null) {
|
||
|
|
cal.setTimeZone(tz);
|
||
|
|
return pos.getIndex();
|
||
|
|
}
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
case 31: // 'O' - TIMEZONE_LOCALIZED_GMT_OFFSET
|
||
|
|
{
|
||
|
|
Style style = (count < 4) ? Style.LOCALIZED_GMT_SHORT : Style.LOCALIZED_GMT;
|
||
|
|
TimeZone tz = tzFormat().parse(style, text, pos, tzTimeType);
|
||
|
|
if (tz != null) {
|
||
|
|
cal.setTimeZone(tz);
|
||
|
|
return pos.getIndex();
|
||
|
|
}
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
case 32: // 'X' - TIMEZONE_ISO
|
||
|
|
{
|
||
|
|
Style style;
|
||
|
|
switch (count) {
|
||
|
|
case 1:
|
||
|
|
style = Style.ISO_BASIC_SHORT;
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
style = Style.ISO_BASIC_FIXED;
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
style = Style.ISO_EXTENDED_FIXED;
|
||
|
|
break;
|
||
|
|
case 4:
|
||
|
|
style = Style.ISO_BASIC_FULL;
|
||
|
|
break;
|
||
|
|
default: // count >= 5
|
||
|
|
style = Style.ISO_EXTENDED_FULL;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
TimeZone tz = tzFormat().parse(style, text, pos, tzTimeType);
|
||
|
|
if (tz != null) {
|
||
|
|
cal.setTimeZone(tz);
|
||
|
|
return pos.getIndex();
|
||
|
|
}
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
case 33: // 'x' - TIMEZONE_ISO_LOCAL
|
||
|
|
{
|
||
|
|
Style style;
|
||
|
|
switch (count) {
|
||
|
|
case 1:
|
||
|
|
style = Style.ISO_BASIC_LOCAL_SHORT;
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
style = Style.ISO_BASIC_LOCAL_FIXED;
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
style = Style.ISO_EXTENDED_LOCAL_FIXED;
|
||
|
|
break;
|
||
|
|
case 4:
|
||
|
|
style = Style.ISO_BASIC_LOCAL_FULL;
|
||
|
|
break;
|
||
|
|
default: // count >= 5
|
||
|
|
style = Style.ISO_EXTENDED_LOCAL_FULL;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
TimeZone tz = tzFormat().parse(style, text, pos, tzTimeType);
|
||
|
|
if (tz != null) {
|
||
|
|
cal.setTimeZone(tz);
|
||
|
|
return pos.getIndex();
|
||
|
|
}
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
case 27: // 'Q' - QUARTER
|
||
|
|
if (count <= 2 && number != null) {
|
||
|
|
// i.e., Q or QQ.
|
||
|
|
// Don't want to parse the quarter if it is a string
|
||
|
|
// while pattern uses numeric style: Q or QQ.
|
||
|
|
// [We computed 'value' above.]
|
||
|
|
cal.set(Calendar.MONTH, (value - 1) * 3);
|
||
|
|
return pos.getIndex();
|
||
|
|
} else {
|
||
|
|
// count >= 3 // i.e., QQQ or QQQQ
|
||
|
|
// Want to be able to parse short, long, and narrow forms.
|
||
|
|
// Try count == 4 first:
|
||
|
|
int newStart = 0;
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 4) {
|
||
|
|
if((newStart = matchQuarterString(text, start, Calendar.MONTH, formatData.quarters, cal)) > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// count == 4 failed, now try count == 3
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 3) {
|
||
|
|
if((newStart = matchQuarterString(text, start, Calendar.MONTH, formatData.shortQuarters, cal)) > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// count == 3 failed, now try count == 5
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 5) {
|
||
|
|
if ((newStart = matchQuarterString(text, start, Calendar.MONTH, formatData.narrowQuarters, cal)) > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// if numeric parsing is on and we got the numeric value already, return it
|
||
|
|
if (getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_ALLOW_NUMERIC) && number != null) {
|
||
|
|
cal.set(Calendar.MONTH, (value - 1) * 3);
|
||
|
|
return pos.getIndex();
|
||
|
|
}
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
|
||
|
|
case 28: // 'q' - STANDALONE QUARTER
|
||
|
|
if (count <= 2 && number != null) {
|
||
|
|
// i.e., q or qq.
|
||
|
|
// Don't want to parse the quarter if it is a string
|
||
|
|
// while pattern uses numeric style: q or qq.
|
||
|
|
// [We computed 'value' above.]
|
||
|
|
cal.set(Calendar.MONTH, (value - 1) * 3);
|
||
|
|
return pos.getIndex();
|
||
|
|
} else {
|
||
|
|
// count >= 3 // i.e., qqq or qqqq
|
||
|
|
// Want to be able to parse short, long, and narrow forms.
|
||
|
|
// Try count == 4 first:
|
||
|
|
int newStart = 0;
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 4) {
|
||
|
|
if((newStart = matchQuarterString(text, start, Calendar.MONTH, formatData.standaloneQuarters, cal)) > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// count == 4 failed, now try count == 3
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 3) {
|
||
|
|
if((newStart = matchQuarterString(text, start, Calendar.MONTH, formatData.standaloneShortQuarters, cal)) > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// count == 3 failed, now try count == 5
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 5) {
|
||
|
|
if ((newStart = matchQuarterString(text, start, Calendar.MONTH, formatData.standaloneNarrowQuarters, cal)) > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// if numeric parsing is on and we got the numeric value already, return it
|
||
|
|
if (getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_ALLOW_NUMERIC) && number != null) {
|
||
|
|
cal.set(Calendar.MONTH, (value - 1) * 3);
|
||
|
|
return pos.getIndex();
|
||
|
|
}
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
|
||
|
|
case 37: // TIME SEPARATOR (no pattern character currently defined, we should
|
||
|
|
// not get here but leave support in for future definition.
|
||
|
|
{
|
||
|
|
// Try matching a time separator.
|
||
|
|
ArrayList<String> data = new ArrayList<>(3);
|
||
|
|
data.add(formatData.getTimeSeparatorString());
|
||
|
|
|
||
|
|
// Add the default, if different from the locale.
|
||
|
|
if (!formatData.getTimeSeparatorString().equals(DateFormatSymbols.DEFAULT_TIME_SEPARATOR)) {
|
||
|
|
data.add(DateFormatSymbols.DEFAULT_TIME_SEPARATOR);
|
||
|
|
}
|
||
|
|
|
||
|
|
// If lenient, add also the alternate, if different from the locale.
|
||
|
|
if (getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_PARTIAL_LITERAL_MATCH) &&
|
||
|
|
!formatData.getTimeSeparatorString().equals(DateFormatSymbols.ALTERNATE_TIME_SEPARATOR)) {
|
||
|
|
data.add(DateFormatSymbols.ALTERNATE_TIME_SEPARATOR);
|
||
|
|
}
|
||
|
|
|
||
|
|
return matchString(text, start, -1 /* => nothing to set */, data.toArray(new String[0]), cal);
|
||
|
|
}
|
||
|
|
|
||
|
|
case 35: // 'b' -- fixed day period (am/pm/midnight/noon)
|
||
|
|
{
|
||
|
|
int ampmStart = subParse(text, start, 'a', count, obeyCount, allowNegative, ambiguousYear, cal,
|
||
|
|
numericLeapMonthFormatter, tzTimeType, dayPeriod);
|
||
|
|
|
||
|
|
if (ampmStart > 0) {
|
||
|
|
return ampmStart;
|
||
|
|
} else {
|
||
|
|
int newStart = 0;
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 3) {
|
||
|
|
if ((newStart = matchDayPeriodString(
|
||
|
|
text, start, formatData.abbreviatedDayPeriods, 2, dayPeriod)) > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 4) {
|
||
|
|
if ((newStart = matchDayPeriodString(
|
||
|
|
text, start, formatData.wideDayPeriods, 2, dayPeriod)) > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 4) {
|
||
|
|
if ((newStart = matchDayPeriodString(
|
||
|
|
text, start, formatData.narrowDayPeriods, 2, dayPeriod)) > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
case 36: // 'B' -- flexible day period
|
||
|
|
{
|
||
|
|
int newStart = 0;
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 3) {
|
||
|
|
if ((newStart = matchDayPeriodString(
|
||
|
|
text, start, formatData.abbreviatedDayPeriods,
|
||
|
|
formatData.abbreviatedDayPeriods.length, dayPeriod)) > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 4) {
|
||
|
|
if ((newStart = matchDayPeriodString(
|
||
|
|
text, start, formatData.wideDayPeriods,
|
||
|
|
formatData.wideDayPeriods.length, dayPeriod)) > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_MULTIPLE_PATTERNS_FOR_MATCH) || count == 4) {
|
||
|
|
if ((newStart = matchDayPeriodString(
|
||
|
|
text, start, formatData.narrowDayPeriods,
|
||
|
|
formatData.narrowDayPeriods.length, dayPeriod)) > 0) {
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return newStart;
|
||
|
|
}
|
||
|
|
|
||
|
|
default:
|
||
|
|
// case 3: // 'd' - DATE
|
||
|
|
// case 5: // 'H' - HOUR_OF_DAY (0..23)
|
||
|
|
// case 6: // 'm' - MINUTE
|
||
|
|
// case 7: // 's' - SECOND
|
||
|
|
// case 10: // 'D' - DAY_OF_YEAR
|
||
|
|
// case 11: // 'F' - DAY_OF_WEEK_IN_MONTH
|
||
|
|
// case 12: // 'w' - WEEK_OF_YEAR
|
||
|
|
// case 13: // 'W' - WEEK_OF_MONTH
|
||
|
|
// case 16: // 'K' - HOUR (0..11)
|
||
|
|
// case 20: // 'u' - EXTENDED_YEAR
|
||
|
|
// case 21: // 'g' - JULIAN_DAY
|
||
|
|
// case 22: // 'A' - MILLISECONDS_IN_DAY
|
||
|
|
// case 34: //
|
||
|
|
|
||
|
|
// Handle "generic" fields
|
||
|
|
if (obeyCount) {
|
||
|
|
if ((start+count) > text.length()) return -start;
|
||
|
|
number = parseInt(text, count, pos, allowNegative,currentNumberFormat);
|
||
|
|
} else {
|
||
|
|
number = parseInt(text, pos, allowNegative,currentNumberFormat);
|
||
|
|
}
|
||
|
|
if (obeyCount && !isLenient() && pos.getIndex() < start + count) {
|
||
|
|
return -start;
|
||
|
|
}
|
||
|
|
if (number != null) {
|
||
|
|
if (patternCharIndex != DateFormat.RELATED_YEAR) {
|
||
|
|
cal.set(field, number.intValue());
|
||
|
|
} else {
|
||
|
|
cal.setRelatedYear(number.intValue());
|
||
|
|
}
|
||
|
|
return pos.getIndex();
|
||
|
|
}
|
||
|
|
return ~start;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* return true if the pattern specified by patternCharIndex is one that allows
|
||
|
|
* numeric fallback regardless of actual pattern size.
|
||
|
|
*/
|
||
|
|
private boolean allowNumericFallback(int patternCharIndex) {
|
||
|
|
if (patternCharIndex == 26 /*'L' STAND_ALONE_MONTH*/ ||
|
||
|
|
patternCharIndex == 19 /*'e' DOW_LOCAL*/ ||
|
||
|
|
patternCharIndex == 25 /*'c' STAND_ALONE_DAY_OF_WEEK*/ ||
|
||
|
|
patternCharIndex == 30 /*'U' YEAR_NAME_FIELD*/ ||
|
||
|
|
patternCharIndex == 27 /* 'Q' - QUARTER*/ ||
|
||
|
|
patternCharIndex == 28 /* 'q' - STANDALONE QUARTER*/) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Parse an integer using numberFormat. This method is semantically
|
||
|
|
* const, but actually may modify fNumberFormat.
|
||
|
|
*/
|
||
|
|
private Number parseInt(String text,
|
||
|
|
ParsePosition pos,
|
||
|
|
boolean allowNegative,
|
||
|
|
NumberFormat fmt) {
|
||
|
|
return parseInt(text, -1, pos, allowNegative, fmt);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Parse an integer using numberFormat up to maxDigits.
|
||
|
|
*/
|
||
|
|
private Number parseInt(String text,
|
||
|
|
int maxDigits,
|
||
|
|
ParsePosition pos,
|
||
|
|
boolean allowNegative,
|
||
|
|
NumberFormat fmt) {
|
||
|
|
Number number;
|
||
|
|
int oldPos = pos.getIndex();
|
||
|
|
if (allowNegative) {
|
||
|
|
number = fmt.parse(text, pos);
|
||
|
|
} else {
|
||
|
|
// Invalidate negative numbers
|
||
|
|
if (fmt instanceof DecimalFormat) {
|
||
|
|
String oldPrefix = ((DecimalFormat)fmt).getNegativePrefix();
|
||
|
|
((DecimalFormat)fmt).setNegativePrefix(SUPPRESS_NEGATIVE_PREFIX);
|
||
|
|
number = fmt.parse(text, pos);
|
||
|
|
((DecimalFormat)fmt).setNegativePrefix(oldPrefix);
|
||
|
|
} else {
|
||
|
|
boolean dateNumberFormat = (fmt instanceof DateNumberFormat);
|
||
|
|
if (dateNumberFormat) {
|
||
|
|
((DateNumberFormat)fmt).setParsePositiveOnly(true);
|
||
|
|
}
|
||
|
|
number = fmt.parse(text, pos);
|
||
|
|
if (dateNumberFormat) {
|
||
|
|
((DateNumberFormat)fmt).setParsePositiveOnly(false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (maxDigits > 0) {
|
||
|
|
// adjust the result to fit into
|
||
|
|
// the maxDigits and move the position back
|
||
|
|
int nDigits = pos.getIndex() - oldPos;
|
||
|
|
if (nDigits > maxDigits) {
|
||
|
|
double val = number.doubleValue();
|
||
|
|
nDigits -= maxDigits;
|
||
|
|
while (nDigits > 0) {
|
||
|
|
val /= 10;
|
||
|
|
nDigits--;
|
||
|
|
}
|
||
|
|
pos.setIndex(oldPos + maxDigits);
|
||
|
|
number = (int) val;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return number;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Counts number of digit code points in the specified text.
|
||
|
|
*
|
||
|
|
* @param text input text
|
||
|
|
* @param start start index, inclusive
|
||
|
|
* @param end end index, exclusive
|
||
|
|
* @return number of digits found in the text in the specified range.
|
||
|
|
*/
|
||
|
|
private static int countDigits(String text, int start, int end) {
|
||
|
|
int numDigits = 0;
|
||
|
|
int idx = start;
|
||
|
|
while (idx < end) {
|
||
|
|
int cp = text.codePointAt(idx);
|
||
|
|
if (UCharacter.isDigit(cp)) {
|
||
|
|
numDigits++;
|
||
|
|
}
|
||
|
|
idx += UCharacter.charCount(cp);
|
||
|
|
}
|
||
|
|
return numDigits;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Translate a pattern, mapping each character in the from string to the
|
||
|
|
* corresponding character in the to string.
|
||
|
|
*/
|
||
|
|
private String translatePattern(String pat, String from, String to) {
|
||
|
|
StringBuilder result = new StringBuilder();
|
||
|
|
boolean inQuote = false;
|
||
|
|
for (int i = 0; i < pat.length(); ++i) {
|
||
|
|
char c = pat.charAt(i);
|
||
|
|
if (inQuote) {
|
||
|
|
if (c == '\'')
|
||
|
|
inQuote = false;
|
||
|
|
} else {
|
||
|
|
if (c == '\'') {
|
||
|
|
inQuote = true;
|
||
|
|
} else if (isSyntaxChar(c)) {
|
||
|
|
int ci = from.indexOf(c);
|
||
|
|
if (ci != -1) {
|
||
|
|
c = to.charAt(ci);
|
||
|
|
}
|
||
|
|
// do not worry on translatepattern if the character is not listed
|
||
|
|
// we do the validity check elsewhere
|
||
|
|
}
|
||
|
|
}
|
||
|
|
result.append(c);
|
||
|
|
}
|
||
|
|
if (inQuote) {
|
||
|
|
throw new IllegalArgumentException("Unfinished quote in pattern");
|
||
|
|
}
|
||
|
|
return result.toString();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Return a pattern string describing this date format.
|
||
|
|
*/
|
||
|
|
public String toPattern() {
|
||
|
|
return pattern;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Return a localized pattern string describing this date format.
|
||
|
|
* <p>
|
||
|
|
* <b>Note:</b> This implementation depends on {@link DateFormatSymbols#getLocalPatternChars()}
|
||
|
|
* to get localized format pattern characters. ICU does not include
|
||
|
|
* localized pattern character data, therefore, unless user sets localized
|
||
|
|
* pattern characters manually, this method returns the same result as
|
||
|
|
* {@link #toPattern()}.
|
||
|
|
*/
|
||
|
|
public String toLocalizedPattern() {
|
||
|
|
return translatePattern(pattern,
|
||
|
|
DateFormatSymbols.patternChars,
|
||
|
|
formatData.localPatternChars);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Apply the given unlocalized pattern string to this date format.
|
||
|
|
*/
|
||
|
|
public void applyPattern(String pat)
|
||
|
|
{
|
||
|
|
this.pattern = pat;
|
||
|
|
parsePattern();
|
||
|
|
|
||
|
|
setLocale(null, null);
|
||
|
|
// reset parsed pattern items
|
||
|
|
patternItems = null;
|
||
|
|
|
||
|
|
// Hack to update use of Gannen year numbering for ja@calendar=japanese -
|
||
|
|
// use only if format is non-numeric (includes 年) and no other fDateOverride.
|
||
|
|
if (calendar != null && calendar.getType().equals("japanese") &&
|
||
|
|
locale != null && locale.getLanguage().equals("ja")) {
|
||
|
|
if (override != null && override.equals("y=jpanyear") && !hasHanYearChar) {
|
||
|
|
// Gannen numbering is set but new pattern should not use it, unset;
|
||
|
|
// use procedure from setNumberFormat(NUmberFormat) to clear overrides
|
||
|
|
numberFormatters = null;
|
||
|
|
overrideMap = null;
|
||
|
|
override = null; // record status
|
||
|
|
} else if (override == null && hasHanYearChar) {
|
||
|
|
// No current override (=> no Gannen numbering) but new pattern needs it;
|
||
|
|
// use procedures from initNumberFormatters / setNumberFormat(String,NumberFormat)
|
||
|
|
numberFormatters = new HashMap<>();
|
||
|
|
overrideMap = new HashMap<>();
|
||
|
|
overrideMap.put('y',"jpanyear");
|
||
|
|
ULocale ovrLoc = new ULocale(locale.getBaseName()+"@numbers=jpanyear");
|
||
|
|
NumberFormat nf = NumberFormat.createInstance(ovrLoc,NumberFormat.NUMBERSTYLE);
|
||
|
|
nf.setGroupingUsed(false);
|
||
|
|
useLocalZeroPaddingNumberFormat = false;
|
||
|
|
numberFormatters.put("jpanyear",nf);
|
||
|
|
override = "y=jpanyear"; // record status
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Apply the given localized pattern string to this date format.
|
||
|
|
*/
|
||
|
|
public void applyLocalizedPattern(String pat) {
|
||
|
|
this.pattern = translatePattern(pat,
|
||
|
|
formatData.localPatternChars,
|
||
|
|
DateFormatSymbols.patternChars);
|
||
|
|
setLocale(null, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Gets the date/time formatting data.
|
||
|
|
* @return a copy of the date-time formatting data associated
|
||
|
|
* with this date-time formatter.
|
||
|
|
*/
|
||
|
|
public DateFormatSymbols getDateFormatSymbols()
|
||
|
|
{
|
||
|
|
return (DateFormatSymbols)formatData.clone();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Allows you to set the date/time formatting data.
|
||
|
|
* @param newFormatSymbols the new symbols
|
||
|
|
*/
|
||
|
|
public void setDateFormatSymbols(DateFormatSymbols newFormatSymbols)
|
||
|
|
{
|
||
|
|
this.formatData = (DateFormatSymbols)newFormatSymbols.clone();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Method for subclasses to access the DateFormatSymbols.
|
||
|
|
*/
|
||
|
|
protected DateFormatSymbols getSymbols() {
|
||
|
|
return formatData;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <strong>[icu]</strong> Gets the time zone formatter which this date/time
|
||
|
|
* formatter uses to format and parse a time zone.
|
||
|
|
*
|
||
|
|
* @return the time zone formatter which this date/time
|
||
|
|
* formatter uses.
|
||
|
|
*/
|
||
|
|
public TimeZoneFormat getTimeZoneFormat() {
|
||
|
|
return tzFormat().freeze();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <strong>[icu]</strong> Allows you to set the time zone formatter.
|
||
|
|
*
|
||
|
|
* @param tzfmt the new time zone formatter
|
||
|
|
*/
|
||
|
|
public void setTimeZoneFormat(TimeZoneFormat tzfmt) {
|
||
|
|
if (tzfmt.isFrozen()) {
|
||
|
|
// If frozen, use it as is.
|
||
|
|
tzFormat = tzfmt;
|
||
|
|
} else {
|
||
|
|
// If not frozen, clone and freeze.
|
||
|
|
tzFormat = tzfmt.cloneAsThawed().freeze();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Overrides Cloneable
|
||
|
|
*/
|
||
|
|
@Override
|
||
|
|
public Object clone() {
|
||
|
|
SimpleDateFormat other = (SimpleDateFormat) super.clone();
|
||
|
|
other.formatData = (DateFormatSymbols) formatData.clone();
|
||
|
|
// We must create a new copy of work buffer used by
|
||
|
|
// the fast numeric field format code.
|
||
|
|
if (this.decimalBuf != null) {
|
||
|
|
other.decimalBuf = new char[DECIMAL_BUF_SIZE];
|
||
|
|
}
|
||
|
|
return other;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Override hashCode.
|
||
|
|
* Generates the hash code for the SimpleDateFormat object
|
||
|
|
*/
|
||
|
|
@Override
|
||
|
|
public int hashCode()
|
||
|
|
{
|
||
|
|
return pattern.hashCode();
|
||
|
|
// just enough fields for a reasonable distribution
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Override equals.
|
||
|
|
*/
|
||
|
|
@Override
|
||
|
|
public boolean equals(Object obj)
|
||
|
|
{
|
||
|
|
if (!super.equals(obj)) return false; // super does class check
|
||
|
|
SimpleDateFormat that = (SimpleDateFormat) obj;
|
||
|
|
return (pattern.equals(that.pattern)
|
||
|
|
&& formatData.equals(that.formatData));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Override writeObject.
|
||
|
|
* See http://docs.oracle.com/javase/6/docs/api/java/io/ObjectOutputStream.html
|
||
|
|
*/
|
||
|
|
private void writeObject(ObjectOutputStream stream) throws IOException{
|
||
|
|
if (defaultCenturyStart == null) {
|
||
|
|
// if defaultCenturyStart is not yet initialized,
|
||
|
|
// calculate and set value before serialization.
|
||
|
|
initializeDefaultCenturyStart(defaultCenturyBase);
|
||
|
|
}
|
||
|
|
initializeTimeZoneFormat(false);
|
||
|
|
stream.defaultWriteObject();
|
||
|
|
stream.writeInt(getContext(DisplayContext.Type.CAPITALIZATION).value());
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Override readObject.
|
||
|
|
* See http://docs.oracle.com/javase/6/docs/api/java/io/ObjectInputStream.html
|
||
|
|
*/
|
||
|
|
private void readObject(ObjectInputStream stream)
|
||
|
|
throws IOException, ClassNotFoundException {
|
||
|
|
stream.defaultReadObject();
|
||
|
|
int capitalizationSettingValue = (serialVersionOnStream > 1)? stream.readInt(): -1;
|
||
|
|
///CLOVER:OFF
|
||
|
|
// don't have old serial data to test with
|
||
|
|
if (serialVersionOnStream < 1) {
|
||
|
|
// didn't have defaultCenturyStart field
|
||
|
|
defaultCenturyBase = System.currentTimeMillis();
|
||
|
|
}
|
||
|
|
///CLOVER:ON
|
||
|
|
else {
|
||
|
|
// fill in dependent transient field
|
||
|
|
parseAmbiguousDatesAsAfter(defaultCenturyStart);
|
||
|
|
}
|
||
|
|
serialVersionOnStream = currentSerialVersion;
|
||
|
|
locale = getLocale(ULocale.VALID_LOCALE);
|
||
|
|
if (locale == null) {
|
||
|
|
// ICU4J 3.6 or older versions did not have UFormat locales
|
||
|
|
// in the serialized data. This is just for preventing the
|
||
|
|
// worst case scenario...
|
||
|
|
locale = ULocale.getDefault(Category.FORMAT);
|
||
|
|
}
|
||
|
|
|
||
|
|
initLocalZeroPaddingNumberFormat();
|
||
|
|
|
||
|
|
setContext(DisplayContext.CAPITALIZATION_NONE);
|
||
|
|
if (capitalizationSettingValue >= 0) {
|
||
|
|
for (DisplayContext context: DisplayContext.values()) {
|
||
|
|
if (context.value() == capitalizationSettingValue) {
|
||
|
|
setContext(context);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// if serialized pre-56 update & turned off partial match switch to new enum value
|
||
|
|
if(getBooleanAttribute(DateFormat.BooleanAttribute.PARSE_PARTIAL_MATCH) == false) {
|
||
|
|
setBooleanAttribute(DateFormat.BooleanAttribute.PARSE_PARTIAL_LITERAL_MATCH, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
parsePattern();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Format the object to an attributed string, and return the corresponding iterator
|
||
|
|
* Overrides superclass method.
|
||
|
|
*
|
||
|
|
* @param obj The object to format
|
||
|
|
* @return <code>AttributedCharacterIterator</code> describing the formatted value.
|
||
|
|
*/
|
||
|
|
@Override
|
||
|
|
public AttributedCharacterIterator formatToCharacterIterator(Object obj) {
|
||
|
|
Calendar cal = calendar;
|
||
|
|
if (obj instanceof Calendar) {
|
||
|
|
cal = (Calendar)obj;
|
||
|
|
} else if (obj instanceof Date) {
|
||
|
|
calendar.setTime((Date)obj);
|
||
|
|
} else if (obj instanceof Number) {
|
||
|
|
calendar.setTimeInMillis(((Number)obj).longValue());
|
||
|
|
} else {
|
||
|
|
throw new IllegalArgumentException("Cannot format given Object as a Date");
|
||
|
|
}
|
||
|
|
StringBuffer toAppendTo = new StringBuffer();
|
||
|
|
FieldPosition pos = new FieldPosition(0);
|
||
|
|
List<FieldPosition> attributes = new ArrayList<>();
|
||
|
|
format(cal, getContext(DisplayContext.Type.CAPITALIZATION), toAppendTo, pos, attributes);
|
||
|
|
|
||
|
|
AttributedString as = new AttributedString(toAppendTo.toString());
|
||
|
|
|
||
|
|
// add DateFormat field attributes to the AttributedString
|
||
|
|
for (int i = 0; i < attributes.size(); i++) {
|
||
|
|
FieldPosition fp = attributes.get(i);
|
||
|
|
Format.Field attribute = fp.getFieldAttribute();
|
||
|
|
as.addAttribute(attribute, attribute, fp.getBeginIndex(), fp.getEndIndex());
|
||
|
|
}
|
||
|
|
// return the CharacterIterator from AttributedString
|
||
|
|
return as.getIterator();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get the locale of this simple date formatter.
|
||
|
|
* It is package accessible. also used in DateIntervalFormat.
|
||
|
|
*
|
||
|
|
* @return locale in this simple date formatter
|
||
|
|
*/
|
||
|
|
ULocale getLocale()
|
||
|
|
{
|
||
|
|
return locale;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check whether the 'field' is smaller than all the fields covered in
|
||
|
|
* pattern, return true if it is.
|
||
|
|
* The sequence of calendar field,
|
||
|
|
* from large to small is: ERA, YEAR, MONTH, DATE, AM_PM, HOUR, MINUTE,...
|
||
|
|
* @param field the calendar field need to check against
|
||
|
|
* @return true if the 'field' is smaller than all the fields
|
||
|
|
* covered in pattern. false otherwise.
|
||
|
|
*/
|
||
|
|
|
||
|
|
boolean isFieldUnitIgnored(int field) {
|
||
|
|
return isFieldUnitIgnored(pattern, field);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Check whether the 'field' is smaller than all the fields covered in
|
||
|
|
* pattern, return true if it is.
|
||
|
|
* The sequence of calendar field,
|
||
|
|
* from large to small is: ERA, YEAR, MONTH, DATE, AM_PM, HOUR, MINUTE,...
|
||
|
|
* @param pattern the pattern to check against
|
||
|
|
* @param field the calendar field need to check against
|
||
|
|
* @return true if the 'field' is smaller than all the fields
|
||
|
|
* covered in pattern. false otherwise.
|
||
|
|
*/
|
||
|
|
static boolean isFieldUnitIgnored(String pattern, int field) {
|
||
|
|
int fieldLevel = CALENDAR_FIELD_TO_LEVEL[field];
|
||
|
|
int level;
|
||
|
|
char ch;
|
||
|
|
boolean inQuote = false;
|
||
|
|
char prevCh = 0;
|
||
|
|
int count = 0;
|
||
|
|
|
||
|
|
for (int i = 0; i < pattern.length(); ++i) {
|
||
|
|
ch = pattern.charAt(i);
|
||
|
|
if (ch != prevCh && count > 0) {
|
||
|
|
level = getLevelFromChar(prevCh);
|
||
|
|
if (fieldLevel <= level) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
count = 0;
|
||
|
|
}
|
||
|
|
if (ch == '\'') {
|
||
|
|
if ((i+1) < pattern.length() && pattern.charAt(i+1) == '\'') {
|
||
|
|
++i;
|
||
|
|
} else {
|
||
|
|
inQuote = ! inQuote;
|
||
|
|
}
|
||
|
|
} else if (!inQuote && isSyntaxChar(ch)) {
|
||
|
|
prevCh = ch;
|
||
|
|
++count;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (count > 0) {
|
||
|
|
// last item
|
||
|
|
level = getLevelFromChar(prevCh);
|
||
|
|
if (fieldLevel <= level) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Format date interval by algorithm.
|
||
|
|
* It is supposed to be used only by CLDR survey tool.
|
||
|
|
*
|
||
|
|
* @param fromCalendar calendar set to the from date in date interval
|
||
|
|
* to be formatted into date interval string
|
||
|
|
* @param toCalendar calendar set to the to date in date interval
|
||
|
|
* to be formatted into date interval string
|
||
|
|
* @param appendTo Output parameter to receive result.
|
||
|
|
* Result is appended to existing contents.
|
||
|
|
* @param pos On input: an alignment field, if desired.
|
||
|
|
* On output: the offsets of the alignment field.
|
||
|
|
* @exception IllegalArgumentException when there is non-recognized
|
||
|
|
* pattern letter
|
||
|
|
* @return Reference to 'appendTo' parameter.
|
||
|
|
* @deprecated This API is ICU internal only.
|
||
|
|
* @hide original deprecated declaration
|
||
|
|
* @hide draft / provisional / internal are hidden on Android
|
||
|
|
*/
|
||
|
|
@Deprecated
|
||
|
|
public final StringBuffer intervalFormatByAlgorithm(Calendar fromCalendar,
|
||
|
|
Calendar toCalendar,
|
||
|
|
StringBuffer appendTo,
|
||
|
|
FieldPosition pos)
|
||
|
|
throws IllegalArgumentException
|
||
|
|
{
|
||
|
|
// not support different calendar types and time zones
|
||
|
|
if ( !fromCalendar.isEquivalentTo(toCalendar) ) {
|
||
|
|
throw new IllegalArgumentException("can not format on two different calendars");
|
||
|
|
}
|
||
|
|
|
||
|
|
Object[] items = getPatternItems();
|
||
|
|
int diffBegin = -1;
|
||
|
|
int diffEnd = -1;
|
||
|
|
|
||
|
|
/* look for different formatting string range */
|
||
|
|
// look for start of difference
|
||
|
|
try {
|
||
|
|
for (int i = 0; i < items.length; i++) {
|
||
|
|
if ( diffCalFieldValue(fromCalendar, toCalendar, items, i) ) {
|
||
|
|
diffBegin = i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( diffBegin == -1 ) {
|
||
|
|
// no difference, single date format
|
||
|
|
return format(fromCalendar, appendTo, pos);
|
||
|
|
}
|
||
|
|
|
||
|
|
// look for end of difference
|
||
|
|
for (int i = items.length-1; i >= diffBegin; i--) {
|
||
|
|
if ( diffCalFieldValue(fromCalendar, toCalendar, items, i) ) {
|
||
|
|
diffEnd = i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} catch ( IllegalArgumentException e ) {
|
||
|
|
throw new IllegalArgumentException(e.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
// full range is different
|
||
|
|
if ( diffBegin == 0 && diffEnd == items.length-1 ) {
|
||
|
|
format(fromCalendar, appendTo, pos);
|
||
|
|
appendTo.append(" \u2013 "); // default separator
|
||
|
|
format(toCalendar, appendTo, pos);
|
||
|
|
return appendTo;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* search for largest calendar field within the different range */
|
||
|
|
int highestLevel = 1000;
|
||
|
|
for (int i = diffBegin; i <= diffEnd; i++) {
|
||
|
|
if ( items[i] instanceof String) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
PatternItem item = (PatternItem)items[i];
|
||
|
|
char ch = item.type;
|
||
|
|
int patternCharIndex = getIndexFromChar(ch);
|
||
|
|
if (patternCharIndex == -1) {
|
||
|
|
throw new IllegalArgumentException("Illegal pattern character " +
|
||
|
|
"'" + ch + "' in \"" +
|
||
|
|
pattern + '"');
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( patternCharIndex < highestLevel ) {
|
||
|
|
highestLevel = patternCharIndex;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* re-calculate diff range, including those calendar field which
|
||
|
|
is in lower level than the largest calendar field covered
|
||
|
|
in diff range calculated. */
|
||
|
|
try {
|
||
|
|
for (int i = 0; i < diffBegin; i++) {
|
||
|
|
if ( lowerLevel(items, i, highestLevel) ) {
|
||
|
|
diffBegin = i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
for (int i = items.length-1; i > diffEnd; i--) {
|
||
|
|
if ( lowerLevel(items, i, highestLevel) ) {
|
||
|
|
diffEnd = i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} catch ( IllegalArgumentException e ) {
|
||
|
|
throw new IllegalArgumentException(e.toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// full range is different
|
||
|
|
if ( diffBegin == 0 && diffEnd == items.length-1 ) {
|
||
|
|
format(fromCalendar, appendTo, pos);
|
||
|
|
appendTo.append(" \u2013 "); // default separator
|
||
|
|
format(toCalendar, appendTo, pos);
|
||
|
|
return appendTo;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// formatting
|
||
|
|
// Initialize
|
||
|
|
pos.setBeginIndex(0);
|
||
|
|
pos.setEndIndex(0);
|
||
|
|
DisplayContext capSetting = getContext(DisplayContext.Type.CAPITALIZATION);
|
||
|
|
|
||
|
|
// formatting date 1
|
||
|
|
for (int i = 0; i <= diffEnd; i++) {
|
||
|
|
if (items[i] instanceof String) {
|
||
|
|
appendTo.append((String)items[i]);
|
||
|
|
} else {
|
||
|
|
PatternItem item = (PatternItem)items[i];
|
||
|
|
if (useFastFormat) {
|
||
|
|
subFormat(appendTo, item.type, item.length, appendTo.length(),
|
||
|
|
i, capSetting, pos, item.type, fromCalendar);
|
||
|
|
} else {
|
||
|
|
appendTo.append(subFormat(item.type, item.length, appendTo.length(),
|
||
|
|
i, capSetting, pos, item.type, fromCalendar));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
appendTo.append(" \u2013 "); // default separator
|
||
|
|
|
||
|
|
// formatting date 2
|
||
|
|
for (int i = diffBegin; i < items.length; i++) {
|
||
|
|
if (items[i] instanceof String) {
|
||
|
|
appendTo.append((String)items[i]);
|
||
|
|
} else {
|
||
|
|
PatternItem item = (PatternItem)items[i];
|
||
|
|
if (useFastFormat) {
|
||
|
|
subFormat(appendTo, item.type, item.length, appendTo.length(),
|
||
|
|
i, capSetting, pos, item.type, toCalendar);
|
||
|
|
} else {
|
||
|
|
appendTo.append(subFormat(item.type, item.length, appendTo.length(),
|
||
|
|
i, capSetting, pos, item.type, toCalendar));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return appendTo;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* check whether the i-th item in 2 calendar is in different value.
|
||
|
|
*
|
||
|
|
* It is supposed to be used only by CLDR survey tool.
|
||
|
|
* It is used by intervalFormatByAlgorithm().
|
||
|
|
*
|
||
|
|
* @param fromCalendar one calendar
|
||
|
|
* @param toCalendar the other calendar
|
||
|
|
* @param items pattern items
|
||
|
|
* @param i the i-th item in pattern items
|
||
|
|
* @exception IllegalArgumentException when there is non-recognized
|
||
|
|
* pattern letter
|
||
|
|
* @return true is i-th item in 2 calendar is in different
|
||
|
|
* value, false otherwise.
|
||
|
|
*/
|
||
|
|
private boolean diffCalFieldValue(Calendar fromCalendar,
|
||
|
|
Calendar toCalendar,
|
||
|
|
Object[] items,
|
||
|
|
int i) throws IllegalArgumentException {
|
||
|
|
if ( items[i] instanceof String) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
PatternItem item = (PatternItem)items[i];
|
||
|
|
char ch = item.type;
|
||
|
|
int patternCharIndex = getIndexFromChar(ch);
|
||
|
|
if (patternCharIndex == -1) {
|
||
|
|
throw new IllegalArgumentException("Illegal pattern character " +
|
||
|
|
"'" + ch + "' in \"" +
|
||
|
|
pattern + '"');
|
||
|
|
}
|
||
|
|
|
||
|
|
final int field = PATTERN_INDEX_TO_CALENDAR_FIELD[patternCharIndex];
|
||
|
|
if (field >= 0) {
|
||
|
|
int value = fromCalendar.get(field);
|
||
|
|
int value_2 = toCalendar.get(field);
|
||
|
|
if ( value != value_2 ) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* check whether the i-th item's level is lower than the input 'level'
|
||
|
|
*
|
||
|
|
* It is supposed to be used only by CLDR survey tool.
|
||
|
|
* It is used by intervalFormatByAlgorithm().
|
||
|
|
*
|
||
|
|
* @param items the pattern items
|
||
|
|
* @param i the i-th item in pattern items
|
||
|
|
* @param level the level with which the i-th pattern item compared to
|
||
|
|
* @exception IllegalArgumentException when there is non-recognized
|
||
|
|
* pattern letter
|
||
|
|
* @return true if i-th pattern item is lower than 'level',
|
||
|
|
* false otherwise
|
||
|
|
*/
|
||
|
|
private boolean lowerLevel(Object[] items, int i, int level)
|
||
|
|
throws IllegalArgumentException {
|
||
|
|
if (items[i] instanceof String) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
PatternItem item = (PatternItem)items[i];
|
||
|
|
char ch = item.type;
|
||
|
|
int patternCharIndex = getLevelFromChar(ch);
|
||
|
|
if (patternCharIndex == -1) {
|
||
|
|
throw new IllegalArgumentException("Illegal pattern character " +
|
||
|
|
"'" + ch + "' in \"" +
|
||
|
|
pattern + '"');
|
||
|
|
}
|
||
|
|
|
||
|
|
if (patternCharIndex >= level) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* allow the user to set the NumberFormat for several fields
|
||
|
|
* It can be a single field like: "y"(year) or "M"(month)
|
||
|
|
* It can be several field combined together: "yMd"(year, month and date)
|
||
|
|
* Note:
|
||
|
|
* 1 symbol field is enough for multiple symbol fields (so "y" will override "yy", "yyy")
|
||
|
|
* If the field is not numeric, then override has no effect (like "MMM" will use abbreviation, not numerical field)
|
||
|
|
*
|
||
|
|
* @param fields the fields to override
|
||
|
|
* @param overrideNF the NumbeferFormat used
|
||
|
|
* @exception IllegalArgumentException when the fields contain invalid field
|
||
|
|
*/
|
||
|
|
public void setNumberFormat(String fields, NumberFormat overrideNF) {
|
||
|
|
overrideNF.setGroupingUsed(false);
|
||
|
|
String nsName = "$" + UUID.randomUUID().toString();
|
||
|
|
|
||
|
|
// initialize mapping if not there
|
||
|
|
if (numberFormatters == null) {
|
||
|
|
numberFormatters = new HashMap<>();
|
||
|
|
}
|
||
|
|
if (overrideMap == null) {
|
||
|
|
overrideMap = new HashMap<>();
|
||
|
|
}
|
||
|
|
|
||
|
|
// separate string into char and add to maps
|
||
|
|
for (int i = 0; i < fields.length(); i++) {
|
||
|
|
char field = fields.charAt(i);
|
||
|
|
if (DateFormatSymbols.patternChars.indexOf(field) == -1) {
|
||
|
|
throw new IllegalArgumentException("Illegal field character " + "'" + field + "' in setNumberFormat.");
|
||
|
|
}
|
||
|
|
overrideMap.put(field, nsName);
|
||
|
|
numberFormatters.put(nsName, overrideNF);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Since one or more of the override number formatters might be complex,
|
||
|
|
// we can't rely on the fast numfmt where we have a partial field override.
|
||
|
|
useLocalZeroPaddingNumberFormat = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* give the NumberFormat used for the field like 'y'(year) and 'M'(year)
|
||
|
|
*
|
||
|
|
* @param field the field the user wants
|
||
|
|
* @return override NumberFormat used for the field
|
||
|
|
*/
|
||
|
|
public NumberFormat getNumberFormat(char field) {
|
||
|
|
Character ovrField = field;
|
||
|
|
if (overrideMap != null && overrideMap.containsKey(ovrField)) {
|
||
|
|
String nsName = overrideMap.get(ovrField).toString();
|
||
|
|
NumberFormat nf = numberFormatters.get(nsName);
|
||
|
|
return nf;
|
||
|
|
} else {
|
||
|
|
return numberFormat;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void initNumberFormatters(ULocale loc) {
|
||
|
|
|
||
|
|
numberFormatters = new HashMap<>();
|
||
|
|
overrideMap = new HashMap<>();
|
||
|
|
processOverrideString(loc,override);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
private void processOverrideString(ULocale loc, String str) {
|
||
|
|
|
||
|
|
if ( str == null || str.length() == 0 )
|
||
|
|
return;
|
||
|
|
|
||
|
|
int start = 0;
|
||
|
|
int end;
|
||
|
|
String nsName;
|
||
|
|
Character ovrField;
|
||
|
|
boolean moreToProcess = true;
|
||
|
|
boolean fullOverride;
|
||
|
|
|
||
|
|
while (moreToProcess) {
|
||
|
|
int delimiterPosition = str.indexOf(";",start);
|
||
|
|
if (delimiterPosition == -1) {
|
||
|
|
moreToProcess = false;
|
||
|
|
end = str.length();
|
||
|
|
} else {
|
||
|
|
end = delimiterPosition;
|
||
|
|
}
|
||
|
|
|
||
|
|
String currentString = str.substring(start,end);
|
||
|
|
int equalSignPosition = currentString.indexOf("=");
|
||
|
|
if (equalSignPosition == -1) { // Simple override string such as "hebrew"
|
||
|
|
nsName = currentString;
|
||
|
|
fullOverride = true;
|
||
|
|
} else { // Field specific override string such as "y=hebrew"
|
||
|
|
nsName = currentString.substring(equalSignPosition+1);
|
||
|
|
ovrField = currentString.charAt(0);
|
||
|
|
overrideMap.put(ovrField,nsName);
|
||
|
|
fullOverride = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
ULocale ovrLoc = new ULocale(loc.getBaseName()+"@numbers="+nsName);
|
||
|
|
NumberFormat nf = NumberFormat.createInstance(ovrLoc,NumberFormat.NUMBERSTYLE);
|
||
|
|
nf.setGroupingUsed(false);
|
||
|
|
|
||
|
|
if (fullOverride) {
|
||
|
|
setNumberFormat(nf);
|
||
|
|
} else {
|
||
|
|
// Since one or more of the override number formatters might be complex,
|
||
|
|
// we can't rely on the fast numfmt where we have a partial field override.
|
||
|
|
useLocalZeroPaddingNumberFormat = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!fullOverride && !numberFormatters.containsKey(nsName)) {
|
||
|
|
numberFormatters.put(nsName,nf);
|
||
|
|
}
|
||
|
|
|
||
|
|
start = delimiterPosition + 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void parsePattern() {
|
||
|
|
hasMinute = false;
|
||
|
|
hasSecond = false;
|
||
|
|
hasHanYearChar = false;
|
||
|
|
|
||
|
|
boolean inQuote = false;
|
||
|
|
for (int i = 0; i < pattern.length(); ++i) {
|
||
|
|
char ch = pattern.charAt(i);
|
||
|
|
if (ch == '\'') {
|
||
|
|
inQuote = !inQuote;
|
||
|
|
}
|
||
|
|
if (ch == '\u5E74') { // don't care whether this is inside quotes
|
||
|
|
hasHanYearChar = true;
|
||
|
|
}
|
||
|
|
if (!inQuote) {
|
||
|
|
if (ch == 'm') {
|
||
|
|
hasMinute = true;
|
||
|
|
}
|
||
|
|
if (ch == 's') {
|
||
|
|
hasSecond = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|