/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.i18n.client;
import com.google.gwt.i18n.client.constants.DateTimeConstants;
import com.google.gwt.i18n.client.impl.cldr.DateTimeFormatInfoImpl_en;
import java.util.HashMap;
import java.util.Map;
/**
* Formats and parses dates and times using locale-sensitive patterns.
*
* <h3>Patterns</h3>
*
* <table>
* <tr>
* <th>Symbol</th>
* <th>Meaning</th>
* <th>Presentation</th>
* <th>Example</th>
* </tr>
*
* <tr>
* <td><code>G</code></td>
* <td>era designator</td>
* <td>Text</td>
* <td><code>AD</code></td>
* </tr>
*
* <tr>
* <td><code>y</code></td>
* <td>year</td>
* <td>Number</td>
* <td><code>1996</code></td>
* </tr>
*
* <tr>
* <td><code>L</code></td>
* <td>standalone month in year</td>
* <td>Text or Number</td>
* <td><code>July (or) 07</code></td>
* </tr>
*
* <tr>
* <td><code>M</code></td>
* <td>month in year</td>
* <td>Text or Number</td>
* <td><code>July (or) 07</code></td>
* </tr>
*
* <tr>
* <td><code>d</code></td>
* <td>day in month</td>
* <td>Number</td>
* <td><code>10</code></td>
* </tr>
*
* <tr>
* <td><code>h</code></td>
* <td>hour in am/pm (1-12)</td>
* <td>Number</td>
* <td><code>12</code></td>
* </tr>
*
* <tr>
* <td><code>H</code></td>
* <td>hour in day (0-23)</td>
* <td>Number</td>
* <td><code>0</code></td>
* </tr>
*
* <tr>
* <td><code>m</code></td>
* <td>minute in hour</td>
* <td>Number</td>
* <td><code>30</code></td>
* </tr>
*
* <tr>
* <td><code>s</code></td>
* <td>second in minute</td>
* <td>Number</td>
* <td><code>55</code></td>
* </tr>
*
* <tr>
* <td><code>S</code></td>
* <td>fractional second</td>
* <td>Number</td>
* <td><code>978</code></td>
* </tr>
*
* <tr>
* <td><code>E</code></td>
* <td>day of week</td>
* <td>Text</td>
* <td><code>Tuesday</code></td>
* </tr>
*
* <tr>
* <td><code>c</code></td>
* <td>standalone day of week</td>
* <td>Text</td>
* <td><code>Tuesday</code></td>
* </tr>
*
* <tr>
* <td><code>a</code></td>
* <td>am/pm marker</td>
* <td>Text</td>
* <td><code>PM</code></td>
* </tr>
*
* <tr>
* <td><code>k</code></td>
* <td>hour in day (1-24)</td>
* <td>Number</td>
* <td><code>24</code></td>
* </tr>
*
* <tr>
* <td><code>K</code></td>
* <td>hour in am/pm (0-11)</td>
* <td>Number</td>
* <td><code>0</code></td>
* </tr>
*
* <tr>
* <td><code>z</code></td>
* <td>time zone</td>
* <td>Text</td>
* <td><code>Pacific Standard Time(see comment)</code></td>
* </tr>
*
* <tr>
* <td><code>Z</code></td>
* <td>time zone (RFC 822)</td>
* <td>Text</td>
* <td><code>-0800(See comment)</code></td>
* </tr>
*
* <tr>
* <td><code>v</code></td>
* <td>time zone id</td>
* <td>Text</td>
* <td><code>America/Los_Angeles(See comment)</code></td>
* </tr>
*
* <tr>
* <td><code>'</code></td>
* <td>escape for text</td>
* <td>Delimiter</td>
* <td><code>'Date='</code></td>
* </tr>
*
* <tr>
* <td><code>''</code></td>
* <td>single quote</td>
* <td>Literal</td>
* <td><code>'o''clock'</code></td>
* </tr>
* </table>
*
* <p>
* The number of pattern letters influences the format, as follows:
* </p>
*
* <dl>
* <dt>Text</dt>
* <dd>if 4 or more, then use the full form; if less than 4, use short or
* abbreviated form if it exists (e.g., <code>"EEEE"</code> produces
* <code>"Monday"</code>, <code>"EEE"</code> produces <code>"Mon"</code>)</dd>
*
* <dt>Number</dt>
* <dd>the minimum number of digits. Shorter numbers are zero-padded to this
* amount (e.g. if <code>"m"</code> produces <code>"6"</code>, <code>"mm"</code>
* produces <code>"06"</code>). Year is handled specially; that is, if the count
* of 'y' is 2, the Year will be truncated to 2 digits. (e.g., if
* <code>"yyyy"</code> produces <code>"1997"</code>, <code>"yy"</code> produces
* <code>"97"</code>.) Unlike other fields, fractional seconds are padded on the
* right with zero.</dd>
*
* <dt>Text or Number</dt>
* <dd>3 or more, use text, otherwise use number. (e.g. <code>"M"</code>
* produces <code>"1"</code>, <code>"MM"</code> produces <code>"01"</code>,
* <code>"MMM"</code> produces <code>"Jan"</code>, and <code>"MMMM"</code>
* produces <code>"January"</code>. Some pattern letters also treat a count
* of 5 specially, meaning a single-letter abbreviation: <code>L</code>,
* <code>M</code>, <code>E</code>, and <code>c</code>.</dd>
* </dl>
*
* <p>
* Any characters in the pattern that are not in the ranges of ['<code>a</code>
* '..'<code>z</code>'] and ['<code>A</code>'..'<code>Z</code>'] will be treated
* as quoted text. For instance, characters like '<code>:</code>', '
* <code>.</code>', '<code> </code>' (space), '<code>#</code>' and '
* <code>@</code>' will appear in the resulting time text even they are not
* embraced within single quotes.
* </p>
*
* <p>
* [Time Zone Handling] Web browsers don't provide all the information we need
* for proper time zone formating -- so GWT has a copy of the required data, for
* your convenience. For simpler cases, one can also use a fallback
* implementation that only keeps track of the current timezone offset. These
* two approaches are called, respectively, Common TimeZones and Simple
* TimeZones, although both are implemented with the same TimeZone class.
*
* "TimeZone createTimeZone(String timezoneData)" returns a Common TimeZone
* object, and "TimeZone createTimeZone(int timeZoneOffsetInMinutes)" returns a
* Simple TimeZone object. The one provided by OS fall into to Simple TimeZone
* category. For formatting purpose, following table shows the behavior of GWT
* DateTimeFormat.
* </p>
* <table>
* <tr>
* <th>Pattern</th>
* <th>Common TimeZone</th>
* <th>Simple TimeZone</th>
* </tr>
* <tr>
* <td>z, zz, zzz</td>
* <td>PDT</td>
* <td>UTC-7</td>
* </tr>
* <tr>
* <td>zzzz</td>
* <td>Pacific Daylight Time</td>
* <td>UTC-7</td>
* </tr>
* <tr>
* <td>Z, ZZ</td>
* <td>-0700</td>
* <td>-0700</td>
* </tr>
* <tr>
* <td>ZZZ</td>
* <td>-07:00</td>
* <td>-07:00</td>
* </tr>
* <tr>
* <td>ZZZZ</td>
* <td>GMT-07:00</td>
* <td>GMT-07:00</td>
* </tr>
* <tr>
* <td>v, vv, vvv, vvvv</td>
* <td>America/Los_Angeles</td>
* <td>Etc/GMT+7</td>
* </tr>
* </table>
*
* <h3>Parsing Dates and Times</h3>
* <p>
* The pattern does not need to specify every field. If the year, month, or
* day is missing from the pattern, the corresponding value will be taken from
* the current date. If the month is specified but the day is not, the day will
* be constrained to the last day within the specified month. If the hour,
* minute, or second is missing, the value defaults to zero.
* </p>
*
* <p>
* As with formatting (described above), the count of pattern letters determines
* the parsing behavior.
* </p>
*
* <dl>
* <dt>Text</dt>
* <dd>4 or more pattern letters--use full form, less than 4--use short or
* abbreviated form if one exists. In parsing, we will always try long format,
* then short.</dd>
*
* <dt>Number</dt>
* <dd>the minimum number of digits.</dd>
*
* <dt>Text or Number</dt>
* <dd>3 or more characters means use text, otherwise use number</dd>
* </dl>
*
* <p>
* Although the current pattern specification doesn't not specify behavior for
* all letters, it may in the future. It is strongly discouraged to use
* unspecified letters as literal text without quoting them.
* </p>
* <p>
* [Note on TimeZone] The time zone support for parsing is limited. Only
* standard GMT and RFC format are supported. Time zone specification using time
* zone id (like America/Los_Angeles), time zone names (like PST, Pacific
* Standard Time) are not supported. Normally, it is too much a burden for a
* client application to load all the time zone symbols. And in almost all those
* cases, it is a better choice to do such parsing on server side through
* certain RPC mechanism. This decision is based on particular use cases we have
* studied; in principle, it could be changed in future versions.
* </p>
*
* <h3>Examples</h3>
* <table>
* <tr>
* <th>Pattern</th>
* <th>Formatted Text</th>
* </tr>
*
* <tr>
* <td><code>"yyyy.MM.dd G 'at' HH:mm:ss vvvv"</code></td>
* <td><code>1996.07.10 AD at 15:08:56 America/Los_Angeles</code></td>
* </tr>
*
* <tr>
* <td><code>"EEE, MMM d, ''yy"</code></td>
* <td><code>Wed, July 10, '96</code></td>
* </tr>
*
* <tr>
* <td><code>"h:mm a"</code></td>
* <td><code>12:08 PM</code></td>
* </tr>
*
* <tr>
* <td><code>"hh 'o''clock' a, zzzz"</code></td>
* <td><code> 12 o'clock PM, Pacific Daylight Time</code></td>
* </tr>
*
* <tr>
* <td><code>"K:mm a, vvvv"</code></td>
* <td><code> 0:00 PM, America/Los_Angeles</code></td>
* </tr>
*
* <tr>
* <td><code>"yyyyy.MMMMM.dd GGG hh:mm aaa"</code></td>
* <td><code>01996.July.10 AD 12:08 PM</code></td>
* </tr>
* </table>
*
* <h3>Additional Parsing Considerations</h3>
* <p>
* When parsing a date string using the abbreviated year pattern (
* <code>"yy"</code>), the parser must interpret the abbreviated year relative
* to some century. It does this by adjusting dates to be within 80 years before
* and 20 years after the time the parser instance is created. For example,
* using a pattern of <code>"MM/dd/yy"</code> and a <code>DateTimeFormat</code>
* object created on Jan 1, 1997, the string <code>"01/11/12"</code> would be
* interpreted as Jan 11, 2012 while the string <code>"05/04/64"</code> would be
* interpreted as May 4, 1964. During parsing, only strings consisting of
* exactly two digits, as defined by {@link java.lang.Character#isDigit(char)},
* will be parsed into the default century. If the year pattern does not have
* exactly two 'y' characters, the year is interpreted literally, regardless of
* the number of digits. For example, using the pattern
* <code>"MM/dd/yyyy"</code>, "01/11/12" parses to Jan 11, 12 A.D.
* </p>
*
* <p>
* When numeric fields abut one another directly, with no intervening delimiter
* characters, they constitute a run of abutting numeric fields. Such runs are
* parsed specially. For example, the format "HHmmss" parses the input text
* "123456" to 12:34:56, parses the input text "12345" to 1:23:45, and fails to
* parse "1234". In other words, the leftmost field of the run is flexible,
* while the others keep a fixed width. If the parse fails anywhere in the run,
* then the leftmost field is shortened by one character, and the entire run is
* parsed again. This is repeated until either the parse succeeds or the
* leftmost field is one character in length. If the parse still fails at that
* point, the parse of the run fails.
* </p>
*
* <p>
* In the current implementation, timezone parsing only supports
* <code>GMT:hhmm</code>, <code>GMT:+hhmm</code>, and <code>GMT:-hhmm</code>.
* </p>
*
* <h3>Example</h3> {@example com.google.gwt.examples.DateTimeFormatExample}
*
* deprecated use {@link com.google.gwt.i18n.shared.DateTimeFormat} instead
*/
// Temporarily remove deprecation to keep from breaking teams that don't allow
// deprecated references.
// @Deprecated
public class DateTimeFormat extends com.google.gwt.i18n.shared.DateTimeFormat {
/**
* Predefined date/time formats -- see {@link CustomDateTimeFormat} if you
* need some format that isn't supplied here.
*
* deprecated use {@link com.google.gwt.i18n.shared.DateTimeFormat.PredefinedFormat} instead
*/
// Temporarily remove deprecation to keep from breaking teams that don't allow
// deprecated references.
// @Deprecated
public enum PredefinedFormat {
// TODO(jat): Javadoc to explain these formats
/**
* ISO 8601 date format, fixed across all locales.
* <p>Example: {@code 2008-10-03T10:29:40.046-04:00}
* <p>http://code.google.com/p/google-web-toolkit/issues/detail?id=3068
* <p>http://www.iso.org/iso/support/faqs/faqs_widely_used_standards/widely_used_standards_other/date_and_time_format.htm
*/
ISO_8601,
/**
* RFC 2822 date format, fixed across all locales.
* <p>Example: {@code Thu, 20 May 2010 17:54:50 -0700}
* <p>http://tools.ietf.org/html/rfc2822#section-3.3
*/
RFC_2822,
DATE_FULL,
DATE_LONG,
DATE_MEDIUM,
DATE_SHORT,
TIME_FULL,
TIME_LONG,
TIME_MEDIUM,
TIME_SHORT,
DATE_TIME_FULL,
DATE_TIME_LONG,
DATE_TIME_MEDIUM,
DATE_TIME_SHORT,
DAY,
HOUR_MINUTE,
HOUR_MINUTE_SECOND,
HOUR24_MINUTE,
HOUR24_MINUTE_SECOND,
MINUTE_SECOND,
MONTH,
MONTH_ABBR,
MONTH_ABBR_DAY,
MONTH_DAY,
MONTH_NUM_DAY,
MONTH_WEEKDAY_DAY,
YEAR,
YEAR_MONTH,
YEAR_MONTH_ABBR,
YEAR_MONTH_ABBR_DAY,
YEAR_MONTH_DAY,
YEAR_MONTH_NUM,
YEAR_MONTH_NUM_DAY,
YEAR_MONTH_WEEKDAY_DAY,
YEAR_QUARTER,
YEAR_QUARTER_ABBR,
}
private static final Map<String, DateTimeFormat> cache;
static {
cache = new HashMap<String, DateTimeFormat>();
}
/**
* Get a DateTimeFormat instance for a predefined format.
*
* <p>See {@link CustomDateTimeFormat} if you need a localized format that is
* not supported here.
*
* @param predef {@link PredefinedFormat} describing desired format
* @return a DateTimeFormat instance for the specified format
*/
public static DateTimeFormat getFormat(PredefinedFormat predef) {
if (usesFixedEnglishStrings(predef)) {
String pattern;
switch (predef) {
case RFC_2822:
pattern = com.google.gwt.i18n.shared.DateTimeFormat.RFC2822_PATTERN;
break;
case ISO_8601:
pattern = com.google.gwt.i18n.shared.DateTimeFormat.ISO8601_PATTERN;
break;
default:
throw new IllegalStateException("Unexpected predef type " + predef);
}
return getFormat(pattern, new DateTimeFormatInfoImpl_en());
}
DateTimeFormatInfo dtfi = getDefaultDateTimeFormatInfo();
String pattern;
switch (predef) {
case DATE_FULL:
pattern = dtfi.dateFormatFull();
break;
case DATE_LONG:
pattern = dtfi.dateFormatLong();
break;
case DATE_MEDIUM:
pattern = dtfi.dateFormatMedium();
break;
case DATE_SHORT:
pattern = dtfi.dateFormatShort();
break;
case DATE_TIME_FULL:
pattern = dtfi.dateTimeFull(dtfi.timeFormatFull(),
dtfi.dateFormatFull());
break;
case DATE_TIME_LONG:
pattern = dtfi.dateTimeLong(dtfi.timeFormatLong(),
dtfi.dateFormatLong());
break;
case DATE_TIME_MEDIUM:
pattern = dtfi.dateTimeMedium(dtfi.timeFormatMedium(),
dtfi.dateFormatMedium());
break;
case DATE_TIME_SHORT:
pattern = dtfi.dateTimeShort(dtfi.timeFormatShort(),
dtfi.dateFormatShort());
break;
case DAY:
pattern = dtfi.formatDay();
break;
case HOUR24_MINUTE:
pattern = dtfi.formatHour24Minute();
break;
case HOUR24_MINUTE_SECOND:
pattern = dtfi.formatHour24MinuteSecond();
break;
case HOUR_MINUTE:
pattern = dtfi.formatHour12Minute();
break;
case HOUR_MINUTE_SECOND:
pattern = dtfi.formatHour12MinuteSecond();
break;
case MINUTE_SECOND:
pattern = dtfi.formatMinuteSecond();
break;
case MONTH:
pattern = dtfi.formatMonthFull();
break;
case MONTH_ABBR:
pattern = dtfi.formatMonthAbbrev();
break;
case MONTH_ABBR_DAY:
pattern = dtfi.formatMonthAbbrevDay();
break;
case MONTH_DAY:
pattern = dtfi.formatMonthFullDay();
break;
case MONTH_NUM_DAY:
pattern = dtfi.formatMonthNumDay();
break;
case MONTH_WEEKDAY_DAY:
pattern = dtfi.formatMonthFullWeekdayDay();
break;
case TIME_FULL:
pattern = dtfi.timeFormatFull();
break;
case TIME_LONG:
pattern = dtfi.timeFormatLong();
break;
case TIME_MEDIUM:
pattern = dtfi.timeFormatMedium();
break;
case TIME_SHORT:
pattern = dtfi.timeFormatShort();
break;
case YEAR:
pattern = dtfi.formatYear();
break;
case YEAR_MONTH:
pattern = dtfi.formatYearMonthFull();
break;
case YEAR_MONTH_ABBR:
pattern = dtfi.formatYearMonthAbbrev();
break;
case YEAR_MONTH_ABBR_DAY:
pattern = dtfi.formatYearMonthAbbrevDay();
break;
case YEAR_MONTH_DAY:
pattern = dtfi.formatYearMonthFullDay();
break;
case YEAR_MONTH_NUM:
pattern = dtfi.formatYearMonthNum();
break;
case YEAR_MONTH_NUM_DAY:
pattern = dtfi.formatYearMonthNumDay();
break;
case YEAR_MONTH_WEEKDAY_DAY:
pattern = dtfi.formatYearMonthWeekdayDay();
break;
case YEAR_QUARTER:
pattern = dtfi.formatYearQuarterFull();
break;
case YEAR_QUARTER_ABBR:
pattern = dtfi.formatYearQuarterShort();
break;
default:
throw new IllegalArgumentException("Unexpected predefined format "
+ predef);
}
return getFormat(pattern, dtfi);
}
/**
* Returns a DateTimeFormat object using the specified pattern. If you need to
* format or parse repeatedly using the same pattern, it is highly recommended
* that you cache the returned <code>DateTimeFormat</code> object and reuse it
* rather than calling this method repeatedly.
*
* <p>Note that the pattern supplied is used as-is -- for example, if you
* supply "MM/dd/yyyy" as the pattern, that is the order you will get the
* fields, even in locales where the order is different. It is recommended to
* use {@link #getFormat(PredefinedFormat)} instead -- if you use this method,
* you are taking responsibility for localizing the patterns yourself.
*
* @param pattern string to specify how the date should be formatted
*
* @return a <code>DateTimeFormat</code> object that can be used for format or
* parse date/time values matching the specified pattern
*
* @throws IllegalArgumentException if the specified pattern could not be
* parsed
*/
public static DateTimeFormat getFormat(String pattern) {
return getFormat(pattern, getDefaultDateTimeFormatInfo());
}
/**
* Retrieve the DateTimeFormat object for full date format. The pattern for
* this format is predefined for each locale.
*
* @return A DateTimeFormat object
* @deprecated use {@link #getFormat(PredefinedFormat)} with
* {@link PredefinedFormat#DATE_FULL} instead
*/
@Deprecated
public static DateTimeFormat getFullDateFormat() {
return getFormat(PredefinedFormat.DATE_FULL);
}
/**
* Retrieve the DateTimeFormat object for full date and time format. The
* pattern for this format is predefined for each locale.
*
* @return A DateTimeFormat object
* @deprecated use {@link #getFormat(PredefinedFormat)} with
* {@link PredefinedFormat#DATE_TIME_FULL} instead
*/
@Deprecated
public static DateTimeFormat getFullDateTimeFormat() {
return getFormat(PredefinedFormat.DATE_TIME_FULL);
}
/**
* Retrieve the DateTimeFormat object for full time format. The pattern for
* this format is predefined for each locale.
*
* @return A DateTimeFormat object
* @deprecated use {@link #getFormat(PredefinedFormat)} with
* {@link PredefinedFormat#TIME_FULL} instead
*/
@Deprecated
public static DateTimeFormat getFullTimeFormat() {
return getFormat(PredefinedFormat.TIME_FULL);
}
/**
* Retrieve the DateTimeFormat object for long date format. The pattern for
* this format is predefined for each locale.
*
* @return A DateTimeFormat object
* @deprecated use {@link #getFormat(PredefinedFormat)} with
* {@link PredefinedFormat#DATE_LONG} instead
*/
@Deprecated
public static DateTimeFormat getLongDateFormat() {
return getFormat(PredefinedFormat.DATE_LONG);
}
/**
* Retrieve the DateTimeFormat object for long date and time format. The
* pattern for this format is predefined for each locale.
*
* @return A DateTimeFormat object
* @deprecated use {@link #getFormat(PredefinedFormat)} with
* {@link PredefinedFormat#DATE_TIME_LONG} instead
*/
@Deprecated
public static DateTimeFormat getLongDateTimeFormat() {
return getFormat(PredefinedFormat.DATE_TIME_LONG);
}
/**
* Retrieve the DateTimeFormat object for long time format. The pattern for
* this format is predefined for each locale.
*
* @return A DateTimeFormat object
* @deprecated use {@link #getFormat(PredefinedFormat)} with
* {@link PredefinedFormat#TIME_LONG} instead
*/
@Deprecated
public static DateTimeFormat getLongTimeFormat() {
return getFormat(PredefinedFormat.TIME_LONG);
}
/**
* Retrieve the DateTimeFormat object for medium date format. The pattern for
* this format is predefined for each locale.
*
* @return A DateTimeFormat object
* @deprecated use {@link #getFormat(PredefinedFormat)} with
* {@link PredefinedFormat#DATE_MEDIUM} instead
*/
@Deprecated
public static DateTimeFormat getMediumDateFormat() {
return getFormat(PredefinedFormat.DATE_MEDIUM);
}
/**
* Retrieve the DateTimeFormat object for medium date and time format. The
* pattern for this format is predefined for each locale.
*
* @return A DateTimeFormat object
* @deprecated use {@link #getFormat(PredefinedFormat)} with
* {@link PredefinedFormat#DATE_TIME_MEDIUM} instead
*/
@Deprecated
public static DateTimeFormat getMediumDateTimeFormat() {
return getFormat(PredefinedFormat.DATE_TIME_MEDIUM);
}
/**
* Retrieve the DateTimeFormat object for medium time format. The pattern for
* this format is predefined for each locale.
*
* @return A DateTimeFormat object
* @deprecated use {@link #getFormat(PredefinedFormat)} with
* {@link PredefinedFormat#TIME_MEDIUM} instead
*/
@Deprecated
public static DateTimeFormat getMediumTimeFormat() {
return getFormat(PredefinedFormat.TIME_MEDIUM);
}
/**
* Retrieve the DateTimeFormat object for short date format. The pattern for
* this format is predefined for each locale.
*
* @return A DateTimeFormat object
* @deprecated use {@link #getFormat(PredefinedFormat)} with
* {@link PredefinedFormat#DATE_SHORT} instead
*/
@Deprecated
public static DateTimeFormat getShortDateFormat() {
return getFormat(PredefinedFormat.DATE_SHORT);
}
/**
* Retrieve the DateTimeFormat object for short date and time format. The
* pattern for this format is predefined for each locale.
*
* @return A DateTimeFormat object
* @deprecated use {@link #getFormat(PredefinedFormat)} with
* {@link PredefinedFormat#DATE_TIME_SHORT} instead
*/
@Deprecated
public static DateTimeFormat getShortDateTimeFormat() {
return getFormat(PredefinedFormat.DATE_TIME_SHORT);
}
/**
* Retrieve the DateTimeFormat object for short time format. The pattern for
* this format is predefined for each locale.
*
* @return A DateTimeFormat object.
* @deprecated use {@link #getFormat(PredefinedFormat)} with
* {@link PredefinedFormat#TIME_SHORT} instead
*/
@Deprecated
public static DateTimeFormat getShortTimeFormat() {
return getFormat(PredefinedFormat.TIME_SHORT);
}
/**
* Internal factory method that provides caching.
*
* @param pattern
* @param dtfi
* @return DateTimeFormat instance
*/
protected static DateTimeFormat getFormat(String pattern,
DateTimeFormatInfo dtfi) {
DateTimeFormatInfo defaultDtfi = getDefaultDateTimeFormatInfo();
DateTimeFormat dtf = null;
if (dtfi == defaultDtfi) {
dtf = cache.get(pattern);
}
if (dtf == null) {
dtf = new DateTimeFormat(pattern, dtfi);
if (dtfi == defaultDtfi) {
cache.put(pattern, dtf);
}
}
return dtf;
}
private static DateTimeFormatInfo getDefaultDateTimeFormatInfo() {
return LocaleInfo.getCurrentLocale().getDateTimeFormatInfo();
}
/**
* Returns true if the predefined format is one that specifies always using
* English names/separators.
* <p>This should be a method on PredefinedFormat, but that would defeat the
* enum optimizations GWT is currently capable of.
* @param predef
* @return true if the specified format requires English names/separators
*/
private static boolean usesFixedEnglishStrings(PredefinedFormat predef) {
switch (predef) {
case RFC_2822:
return true;
case ISO_8601:
return true;
default:
return false;
}
}
/**
* Constructs a format object using the specified pattern and the date time
* constants for the default locale.
*
* @param pattern string pattern specification
*/
protected DateTimeFormat(String pattern) {
this(pattern, getDefaultDateTimeFormatInfo());
}
/**
* Constructs a format object using the specified pattern and user-supplied
* date time constants.
*
* @param pattern string pattern specification
* @param dateTimeConstants locale specific symbol collection
* @deprecated use {@link #DateTimeFormat(String, DateTimeFormatInfo)}
*/
@Deprecated
protected DateTimeFormat(String pattern, DateTimeConstants dateTimeConstants) {
this(pattern, new DateTimeFormatInfoAdapter(dateTimeConstants));
}
/**
* Constructs a format object using the specified pattern and user-supplied
* date time constants.
*
* @param pattern string pattern specification
* @param dtfi DateTimeFormatInfo instance to use
*/
protected DateTimeFormat(String pattern, DateTimeFormatInfo dtfi) {
super(pattern, dtfi);
}
}