/* | |
******************************************************************************* | |
* Copyright (C) 1996-2011, International Business Machines Corporation and * | |
* others. All Rights Reserved. * | |
******************************************************************************* | |
*/ | |
package com.ibm.icu.text; | |
import java.text.AttributedCharacterIterator; | |
import java.text.AttributedCharacterIterator.Attribute; | |
import java.text.AttributedString; | |
import java.text.CharacterIterator; | |
import java.text.FieldPosition; | |
import java.text.ParsePosition; | |
import java.util.Date; | |
import java.util.Locale; | |
import java.util.Map; | |
import java.util.Map.Entry; | |
import com.ibm.icu.util.Calendar; | |
import com.ibm.icu.util.ULocale; | |
/** | |
* {@icuenhanced java.text.SimpleDateFormat}.{@icu _usage_} | |
* | |
* <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> | |
* <code>SimpleDateFormat</code> allows you to start by choosing | |
* any user-defined patterns for date-time formatting. However, you | |
* are encouraged to create a date-time formatter with either | |
* <code>getTimeInstance</code>, <code>getDateInstance</code>, or | |
* <code>getDateTimeInstance</code> in <code>DateFormat</code>. Each | |
* of these class methods can return a date/time formatter initialized | |
* with a default format pattern. You may modify the format pattern | |
* using the <code>applyPattern</code> methods as desired. | |
* For more information on using these methods, see | |
* {@link DateFormat}. | |
* | |
* <p> | |
* <strong>Time Format Syntax:</strong> | |
* <p> | |
* To specify the time format use a <em>time pattern</em> string. | |
* In this pattern, all ASCII letters are reserved as pattern letters, | |
* which are defined as the following: | |
* <blockquote> | |
* <pre> | |
* Symbol Meaning Presentation Example | |
* ------ ------- ------------ ------- | |
* G era designator (Text) AD | |
* y† year (Number) 1996 | |
* Y* year (week of year) (Number) 1997 | |
* u* extended year (Number) 4601 | |
* M month in year (Text & Number) July & 07 | |
* d day in month (Number) 10 | |
* h hour in am/pm (1~12) (Number) 12 | |
* H hour in day (0~23) (Number) 0 | |
* m minute in hour (Number) 30 | |
* s second in minute (Number) 55 | |
* S fractional second (Number) 978 | |
* E day of week (Text) Tuesday | |
* e* day of week (local 1~7) (Text & Number) Tuesday & 2 | |
* D day in year (Number) 189 | |
* F day of week in month (Number) 2 (2nd Wed in July) | |
* w week in year (Number) 27 | |
* W week in month (Number) 2 | |
* a am/pm marker (Text) PM | |
* k hour in day (1~24) (Number) 24 | |
* K hour in am/pm (0~11) (Number) 0 | |
* z time zone (Text) Pacific Standard Time | |
* Z time zone (RFC 822) (Number) -0800 | |
* v time zone (generic) (Text) Pacific Time | |
* V time zone (location) (Text) United States (Los Angeles) | |
* g* Julian day (Number) 2451334 | |
* A* milliseconds in day (Number) 69540000 | |
* Q* quarter in year (Text & Number) Q1 & 01 | |
* c* stand alone day of week (Text & Number) Tuesday & 2 | |
* L* stand alone month (Text & Number) July & 07 | |
* q* stand alone quarter (Text & Number) Q1 & 01 | |
* ' escape for text (Delimiter) 'Date=' | |
* '' single quote (Literal) 'o''clock' | |
* </pre> | |
* </blockquote> | |
* <tt><b>*</b></tt> These items are not supported by Java's SimpleDateFormat.<br> | |
* <tt><b>†</b></tt> ICU interprets a single 'y' differently than Java.</p> | |
* <p> | |
* The count of pattern letters determine the format. | |
* <p> | |
* <strong>(Text)</strong>: 4 or more pattern letters--use full form, | |
* < 4--use short or abbreviated form if one exists. | |
* <p> | |
* <strong>(Number)</strong>: the minimum number of digits. Shorter | |
* numbers are zero-padded to this amount. Year is handled specially; | |
* that is, if the count of 'y' is 2, the Year will be truncated to 2 digits. | |
* (e.g., if "yyyy" produces "1997", "yy" produces "97".) | |
* Unlike other fields, fractional seconds are padded on the right with zero. | |
* <p> | |
* <strong>(Text & Number)</strong>: 3 or over, use text, otherwise use number. | |
* <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 com.ibm.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. | |
* | |
* <h4>Synchronization</h4> | |
* | |
* 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 com.ibm.icu.util.Calendar | |
* @see com.ibm.icu.util.GregorianCalendar | |
* @see com.ibm.icu.util.TimeZone | |
* @see DateFormat | |
* @see DateFormatSymbols | |
* @see DecimalFormat | |
* @author Mark Davis, Chen-Lieh Huang, Alan Liu | |
* @stable ICU 2.0 | |
*/ | |
public class SimpleDateFormat extends DateFormat { | |
private static final long serialVersionUID = 1L; | |
/** | |
* Constructs a SimpleDateFormat using the default pattern for the default | |
* locale. <b>Note:</b> Not all locales support SimpleDateFormat; for full | |
* generality, use the factory methods in the DateFormat class. | |
* | |
* @see DateFormat | |
* @stable ICU 2.0 | |
*/ | |
public SimpleDateFormat() { | |
super(new java.text.SimpleDateFormat()); | |
} | |
/** | |
* Constructs a SimpleDateFormat using the given pattern in the default | |
* locale. <b>Note:</b> Not all locales support SimpleDateFormat; for full | |
* generality, use the factory methods in the DateFormat class. | |
* @stable ICU 2.0 | |
*/ | |
public SimpleDateFormat(String pattern) | |
{ | |
super(new java.text.SimpleDateFormat(pattern)); | |
} | |
/** | |
* 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. | |
* @stable ICU 2.0 | |
*/ | |
public SimpleDateFormat(String pattern, Locale loc) | |
{ | |
super(new java.text.SimpleDateFormat(pattern, loc)); | |
} | |
/** | |
* 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. | |
* @stable ICU 3.2 | |
*/ | |
public SimpleDateFormat(String pattern, ULocale loc) | |
{ | |
this(pattern, loc.toLocale()); | |
} | |
/** | |
* 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 | |
* @stable ICU 4.2 | |
*/ | |
public SimpleDateFormat(String pattern, String override, ULocale loc) | |
{ | |
throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base"); | |
} | |
/** | |
* Constructs a SimpleDateFormat using the given pattern and | |
* locale-specific symbol data. | |
* Warning: uses default locale for digits! | |
* @stable ICU 2.0 | |
*/ | |
public SimpleDateFormat(String pattern, DateFormatSymbols formatData) | |
{ | |
super(new java.text.SimpleDateFormat(pattern, formatData.dfs)); | |
} | |
/** | |
* 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>. | |
* @stable ICU 2.0 | |
*/ | |
public void set2DigitYearStart(Date startDate) { | |
((java.text.SimpleDateFormat)dateFormat).set2DigitYearStart(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 | |
* @stable ICU 2.0 | |
*/ | |
public Date get2DigitYearStart() { | |
return ((java.text.SimpleDateFormat)dateFormat).get2DigitYearStart(); | |
} | |
/** | |
* 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 | |
* @stable ICU 2.0 | |
*/ | |
public StringBuffer format(Calendar cal, StringBuffer toAppendTo, | |
FieldPosition pos) { | |
StringBuffer result; | |
FieldPosition jdkPos = toJDKFieldPosition(pos); | |
synchronized(dateFormat) { | |
java.util.Calendar oldCal = dateFormat.getCalendar(); | |
dateFormat.setCalendar(cal.calendar); | |
result = dateFormat.format(cal.getTime(), toAppendTo, jdkPos); | |
dateFormat.setCalendar(oldCal); | |
} | |
if (jdkPos != null) { | |
pos.setBeginIndex(jdkPos.getBeginIndex()); | |
pos.setEndIndex(jdkPos.getEndIndex()); | |
} | |
return result; | |
} | |
/** | |
* Overrides superclass method | |
* @stable ICU 2.0 | |
*/ | |
public void setNumberFormat(NumberFormat newNumberFormat) { | |
super.setNumberFormat(newNumberFormat); | |
} | |
/** | |
* Overrides DateFormat | |
* @see DateFormat | |
* @stable ICU 2.0 | |
*/ | |
public void parse(String text, Calendar cal, ParsePosition parsePos) | |
{ | |
// Note: parsed time zone won't be set in the result calendar | |
cal.setTime(dateFormat.parse(text, parsePos)); | |
} | |
/** | |
* Return a pattern string describing this date format. | |
* @stable ICU 2.0 | |
*/ | |
public String toPattern() { | |
return ((java.text.SimpleDateFormat)dateFormat).toPattern(); | |
} | |
/** | |
* Return a localized pattern string describing this date format. | |
* @stable ICU 2.0 | |
*/ | |
public String toLocalizedPattern() { | |
return ((java.text.SimpleDateFormat)dateFormat).toLocalizedPattern(); | |
} | |
/** | |
* Apply the given unlocalized pattern string to this date format. | |
* @stable ICU 2.0 | |
*/ | |
public void applyPattern(String pat) { | |
((java.text.SimpleDateFormat)dateFormat).applyPattern(pat); | |
} | |
/** | |
* Apply the given localized pattern string to this date format. | |
* @stable ICU 2.0 | |
*/ | |
public void applyLocalizedPattern(String pat) { | |
((java.text.SimpleDateFormat)dateFormat).applyLocalizedPattern(pat); | |
} | |
/** | |
* Gets the date/time formatting data. | |
* @return a copy of the date-time formatting data associated | |
* with this date-time formatter. | |
* @stable ICU 2.0 | |
*/ | |
public DateFormatSymbols getDateFormatSymbols() { | |
return new DateFormatSymbols(((java.text.SimpleDateFormat)dateFormat).getDateFormatSymbols()); | |
} | |
/** | |
* Allows you to set the date/time formatting data. | |
* @param newFormatSymbols the new symbols | |
* @stable ICU 2.0 | |
*/ | |
public void setDateFormatSymbols(DateFormatSymbols newFormatSymbols) { | |
((java.text.SimpleDateFormat)dateFormat).setDateFormatSymbols(newFormatSymbols.dfs); | |
} | |
// For clone to use | |
private SimpleDateFormat(java.text.SimpleDateFormat sdf) { | |
super(sdf); | |
} | |
/** | |
* Overrides Cloneable | |
* @stable ICU 2.0 | |
*/ | |
public Object clone() { | |
return new SimpleDateFormat((java.text.SimpleDateFormat)dateFormat.clone()); | |
} | |
/** | |
* Override hashCode. | |
* Generates the hash code for the SimpleDateFormat object | |
* @stable ICU 2.0 | |
*/ | |
public int hashCode() | |
{ | |
return super.hashCode(); | |
} | |
/** | |
* Override equals. | |
* @stable ICU 2.0 | |
*/ | |
public boolean equals(Object obj) | |
{ | |
return super.equals(obj); | |
} | |
/** | |
* 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. | |
* | |
* @stable ICU 3.8 | |
*/ | |
public AttributedCharacterIterator formatToCharacterIterator(Object obj) { | |
AttributedCharacterIterator it = dateFormat.formatToCharacterIterator(obj); | |
// Extract formatted String first | |
StringBuilder sb = new StringBuilder(); | |
for (char c = it.first(); c != CharacterIterator.DONE; c = it.next()) { | |
sb.append(c); | |
} | |
// Create AttributedString | |
AttributedString attrstr = new AttributedString(sb.toString()); | |
// Map JDK Field to ICU Field | |
int idx = 0; | |
it.first(); | |
while (idx < it.getEndIndex()) { | |
int end = it.getRunLimit(); | |
Map<Attribute, Object> attributes = it.getAttributes(); | |
if (attributes != null) { | |
for (Entry<Attribute, Object> entry : attributes.entrySet()) { | |
Attribute attr = entry.getKey(); | |
Object val = entry.getValue(); | |
if (attr.equals(java.text.DateFormat.Field.AM_PM)) { | |
val = attr = Field.AM_PM; | |
} else if (attr.equals(java.text.DateFormat.Field.DAY_OF_MONTH)) { | |
val = attr = Field.DAY_OF_MONTH; | |
} else if (attr.equals(java.text.DateFormat.Field.DAY_OF_WEEK)) { | |
val = attr = Field.DAY_OF_WEEK ; | |
} else if (attr.equals(java.text.DateFormat.Field.DAY_OF_WEEK_IN_MONTH)) { | |
val = attr = Field.DAY_OF_WEEK_IN_MONTH ; | |
} else if (attr.equals(java.text.DateFormat.Field.DAY_OF_YEAR)) { | |
val = attr = Field.DAY_OF_YEAR; | |
} else if (attr.equals(java.text.DateFormat.Field.ERA)) { | |
val = attr = Field.ERA; | |
} else if (attr.equals(java.text.DateFormat.Field.HOUR_OF_DAY0)) { | |
val = attr = Field.HOUR_OF_DAY0; | |
} else if (attr.equals(java.text.DateFormat.Field.HOUR_OF_DAY1)) { | |
val = attr = Field.HOUR_OF_DAY1; | |
} else if (attr.equals(java.text.DateFormat.Field.HOUR0)) { | |
val = attr = Field.HOUR0; | |
} else if (attr.equals(java.text.DateFormat.Field.HOUR1)) { | |
val = attr = Field.HOUR1; | |
} else if (attr.equals(java.text.DateFormat.Field.MILLISECOND)) { | |
val = attr = Field.MILLISECOND; | |
} else if (attr.equals(java.text.DateFormat.Field.MINUTE)) { | |
val = attr = Field.MINUTE; | |
} else if (attr.equals(java.text.DateFormat.Field.MONTH)) { | |
val = attr = Field.MONTH; | |
} else if (attr.equals(java.text.DateFormat.Field.SECOND)) { | |
val = attr = Field.SECOND; | |
} else if (attr.equals(java.text.DateFormat.Field.TIME_ZONE)) { | |
val = attr = Field.TIME_ZONE; | |
} else if (attr.equals(java.text.DateFormat.Field.WEEK_OF_MONTH)) { | |
val = attr = Field.WEEK_OF_MONTH; | |
} else if (attr.equals(java.text.DateFormat.Field.WEEK_OF_YEAR)) { | |
val = attr = Field.WEEK_OF_YEAR; | |
} else if (attr.equals(java.text.DateFormat.Field.YEAR)) { | |
val = attr = Field.YEAR; | |
} | |
attrstr.addAttribute(attr, val, idx, end); | |
} | |
} | |
idx = end; | |
while (it.getIndex() < idx) { | |
it.next(); | |
} | |
} | |
return attrstr.getIterator(); | |
} | |
} |