1658 lines
71 KiB
C++
1658 lines
71 KiB
C++
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/*
|
|
* Copyright (C) 1997-2016, International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
*******************************************************************************
|
|
*
|
|
* File SMPDTFMT.H
|
|
*
|
|
* Modification History:
|
|
*
|
|
* Date Name Description
|
|
* 02/19/97 aliu Converted from java.
|
|
* 07/09/97 helena Make ParsePosition into a class.
|
|
* 07/21/98 stephen Added GMT_PLUS, GMT_MINUS
|
|
* Changed setTwoDigitStartDate to set2DigitYearStart
|
|
* Changed getTwoDigitStartDate to get2DigitYearStart
|
|
* Removed subParseLong
|
|
* Removed getZoneIndex (added in DateFormatSymbols)
|
|
* 06/14/99 stephen Removed fgTimeZoneDataSuffix
|
|
* 10/14/99 aliu Updated class doc to describe 2-digit year parsing
|
|
* {j28 4182066}.
|
|
*******************************************************************************
|
|
*/
|
|
|
|
#ifndef SMPDTFMT_H
|
|
#define SMPDTFMT_H
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
/**
|
|
* \file
|
|
* \brief C++ API: Format and parse dates in a language-independent manner.
|
|
*/
|
|
|
|
#if !UCONFIG_NO_FORMATTING
|
|
|
|
#include "unicode/datefmt.h"
|
|
#include "unicode/udisplaycontext.h"
|
|
#include "unicode/tzfmt.h" /* for UTimeZoneFormatTimeType */
|
|
#include "unicode/brkiter.h"
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
class DateFormatSymbols;
|
|
class DateFormat;
|
|
class MessageFormat;
|
|
class FieldPositionHandler;
|
|
class TimeZoneFormat;
|
|
class SharedNumberFormat;
|
|
class SimpleDateFormatMutableNFs;
|
|
|
|
namespace number {
|
|
class LocalizedNumberFormatter;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* SimpleDateFormat is a concrete class for formatting and parsing dates in a
|
|
* language-independent manner. It allows for formatting (millis -> text),
|
|
* parsing (text -> millis), and normalization. Formats/Parses a date or time,
|
|
* which is the standard milliseconds since 24:00 GMT, Jan 1, 1970.
|
|
* <P>
|
|
* Clients are encouraged to create a date-time formatter using DateFormat::getInstance(),
|
|
* getDateInstance(), getDateInstance(), or getDateTimeInstance() rather than
|
|
* explicitly constructing an instance of SimpleDateFormat. This way, the client
|
|
* is guaranteed to get an appropriate formatting pattern for whatever locale the
|
|
* program is running in. However, if the client needs something more unusual than
|
|
* the default patterns in the locales, he can construct a SimpleDateFormat directly
|
|
* and give it an appropriate pattern (or use one of the factory methods on DateFormat
|
|
* and modify the pattern after the fact with toPattern() and applyPattern().
|
|
*
|
|
* <p><strong>Date and Time Patterns:</strong></p>
|
|
*
|
|
* <p>Date and time formats are specified by <em>date and time pattern</em> strings.
|
|
* Within date and time pattern strings, all unquoted ASCII letters [A-Za-z] are reserved
|
|
* as pattern letters representing calendar fields. <code>SimpleDateFormat</code> supports
|
|
* the date and time formatting algorithm and pattern letters defined by
|
|
* <a href="http://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table">UTS#35
|
|
* Unicode Locale Data Markup Language (LDML)</a> and further documented for ICU in the
|
|
* <a href="https://sites.google.com/site/icuprojectuserguide/formatparse/datetime?pli=1#TOC-Date-Field-Symbol-Table">ICU
|
|
* User Guide</a>. The following pattern letters are currently available (note that the actual
|
|
* values depend on CLDR and may change from the examples shown here):</p>
|
|
*
|
|
* <table border="1">
|
|
* <tr>
|
|
* <th>Field</th>
|
|
* <th style="text-align: center">Sym.</th>
|
|
* <th style="text-align: center">No.</th>
|
|
* <th>Example</th>
|
|
* <th>Description</th>
|
|
* </tr>
|
|
* <tr>
|
|
* <th rowspan="3">era</th>
|
|
* <td style="text-align: center" rowspan="3">G</td>
|
|
* <td style="text-align: center">1..3</td>
|
|
* <td>AD</td>
|
|
* <td rowspan="3">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">4</td>
|
|
* <td>Anno Domini</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">5</td>
|
|
* <td>A</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <th rowspan="6">year</th>
|
|
* <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 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 style="text-align: center">Y</td>
|
|
* <td style="text-align: center">1..n</td>
|
|
* <td>1997</td>
|
|
* <td>Year (in "Week of Year" based calendars). Normally the length specifies the padding,
|
|
* but for two letters it also specifies the maximum length. This year designation is used in ISO
|
|
* year-week calendar as defined by ISO 8601, but can be used in non-Gregorian based calendar systems
|
|
* where week date processing is desired. May not always be the same value as calendar year.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">u</td>
|
|
* <td style="text-align: center">1..n</td>
|
|
* <td>4601</td>
|
|
* <td>Extended year. This is a single number designating the year of this calendar system, encompassing
|
|
* all supra-year fields. For example, for the Julian calendar system, year numbers are positive, with an
|
|
* era of BCE or CE. An extended year value for the Julian calendar system assigns positive values to CE
|
|
* years and negative values to BCE years, with 1 BCE being year 0.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center" rowspan="3">U</td>
|
|
* <td style="text-align: center">1..3</td>
|
|
* <td>甲子</td>
|
|
* <td rowspan="3">Cyclic year name. Calendars such as the Chinese lunar calendar (and related calendars)
|
|
* and the Hindu calendars use 60-year cycles of year names. Use one through three letters for the abbreviated
|
|
* name, four for the full (wide) name, or five for the narrow name (currently the data only provides abbreviated names,
|
|
* which will be used for all requested name widths). If the calendar does not provide cyclic year name data,
|
|
* or if the year value to be formatted is out of the range of years for which cyclic name data is provided,
|
|
* then numeric formatting is used (behaves like 'y').</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">4</td>
|
|
* <td>(currently also 甲子)</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">5</td>
|
|
* <td>(currently also 甲子)</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <th rowspan="6">quarter</th>
|
|
* <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="3" style="text-align: center">q</td>
|
|
* <td style="text-align: center">1..2</td>
|
|
* <td>02</td>
|
|
* <td rowspan="3"><b>Stand-Alone</b> Quarter - Use one or two for the numerical quarter, three for the abbreviation,
|
|
* or four for the full 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>
|
|
* <th rowspan="8">month</th>
|
|
* <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 rowspan="4" style="text-align: center">L</td>
|
|
* <td style="text-align: center">1..2</td>
|
|
* <td>09</td>
|
|
* <td rowspan="4"><b>Stand-Alone</b> Month - Use one or two for the numerical month, three for the abbreviation,
|
|
* four for the full (wide) name, or 5 for the narrow name. With two ("LL"), 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>
|
|
* <th rowspan="2">week</th>
|
|
* <td style="text-align: center">w</td>
|
|
* <td style="text-align: center">1..2</td>
|
|
* <td>27</td>
|
|
* <td>Week of Year. Use "w" to show the minimum number of digits, or "ww" to always show two digits
|
|
* (zero-padding if necessary, e.g. "08").</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">W</td>
|
|
* <td style="text-align: center">1</td>
|
|
* <td>3</td>
|
|
* <td>Week of Month</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <th rowspan="4">day</th>
|
|
* <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 style="text-align: center">D</td>
|
|
* <td style="text-align: center">1..3</td>
|
|
* <td>345</td>
|
|
* <td>Day of year</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">F</td>
|
|
* <td style="text-align: center">1</td>
|
|
* <td>2</td>
|
|
* <td>Day of Week in Month. The example is for the 2nd Wed in July</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">g</td>
|
|
* <td style="text-align: center">1..n</td>
|
|
* <td>2451334</td>
|
|
* <td>Modified Julian day. This is different from the conventional Julian day number in two regards.
|
|
* First, it demarcates days at local zone midnight, rather than noon GMT. Second, it is a local number;
|
|
* that is, it depends on the local time zone. It can be thought of as a single number that encompasses
|
|
* all the date-related fields.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <th rowspan="14">week<br>
|
|
* day</th>
|
|
* <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 rowspan="5" style="text-align: center">e</td>
|
|
* <td style="text-align: center">1..2</td>
|
|
* <td>2</td>
|
|
* <td rowspan="5">Local day of week. Same as E except adds a numeric value that will depend on the local
|
|
* starting day of the week, using one or two letters. For this example, Monday is the first day of the week.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">3</td>
|
|
* <td>Tue</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 rowspan="5" style="text-align: center">c</td>
|
|
* <td style="text-align: center">1</td>
|
|
* <td>2</td>
|
|
* <td rowspan="5"><b>Stand-Alone</b> local day of week - Use one letter for the local numeric value (same
|
|
* as 'e'), three 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">3</td>
|
|
* <td>Tue</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>
|
|
* <th>period</th>
|
|
* <td style="text-align: center">a</td>
|
|
* <td style="text-align: center">1</td>
|
|
* <td>AM</td>
|
|
* <td>AM or PM</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <th rowspan="4">hour</th>
|
|
* <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">K</td>
|
|
* <td style="text-align: center">1..2</td>
|
|
* <td>0</td>
|
|
* <td>Hour [0-11]. When used in a skeleton, only matches K or h, see above. Use KK for zero padding.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">k</td>
|
|
* <td style="text-align: center">1..2</td>
|
|
* <td>24</td>
|
|
* <td>Hour [1-24]. When used in a skeleton, only matches k or H, see above. Use kk for zero padding.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <th>minute</th>
|
|
* <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>
|
|
* <th rowspan="3">second</th>
|
|
* <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 style="text-align: center">S</td>
|
|
* <td style="text-align: center">1..n</td>
|
|
* <td>3450</td>
|
|
* <td>Fractional Second - truncates (like other time fields) to the count of letters when formatting.
|
|
* Appends zeros if more than 3 letters specified. Truncates at three significant digits when parsing.
|
|
* (example shows display using pattern SSSS for seconds value 12.34567)</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">A</td>
|
|
* <td style="text-align: center">1..n</td>
|
|
* <td>69540000</td>
|
|
* <td>Milliseconds in day. This field behaves <i>exactly</i> like a composite of all time-related fields,
|
|
* not including the zone fields. As such, it also reflects discontinuities of those fields on DST transition
|
|
* days. On a day of DST onset, it will jump forward. On a day of DST cessation, it will jump backward. This
|
|
* reflects the fact that is must be combined with the offset field to obtain a unique local time value.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <th rowspan="23">zone</th>
|
|
* <td rowspan="2" style="text-align: center">z</td>
|
|
* <td style="text-align: center">1..3</td>
|
|
* <td>PDT</td>
|
|
* <td>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="3" style="text-align: center">Z</td>
|
|
* <td style="text-align: center">1..3</td>
|
|
* <td>-0800</td>
|
|
* <td>The <i>ISO8601 basic format</i> with hours, minutes and optional seconds fields.
|
|
* The format is equivalent to RFC 822 zone format (when optional seconds field is absent).
|
|
* This is equivalent to the "xxxx" specifier.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">4</td>
|
|
* <td>GMT-8:00</td>
|
|
* <td>The <i>long localized GMT format</i>.
|
|
* This is equivalent to the "OOOO" specifier.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">5</td>
|
|
* <td>-08:00<br>
|
|
* -07:52:58</td>
|
|
* <td>The <i>ISO8601 extended format</i> with hours, minutes and optional seconds fields.
|
|
* The ISO8601 UTC indicator "Z" is used when local time offset is 0.
|
|
* This is equivalent to the "XXXXX" specifier.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td rowspan="2" style="text-align: center">O</td>
|
|
* <td style="text-align: center">1</td>
|
|
* <td>GMT-8</td>
|
|
* <td>The <i>short localized GMT format</i>.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">4</td>
|
|
* <td>GMT-08:00</td>
|
|
* <td>The <i>long localized GMT format</i>.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td rowspan="2" style="text-align: center">v</td>
|
|
* <td style="text-align: center">1</td>
|
|
* <td>PT</td>
|
|
* <td>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>
|
|
* <tr>
|
|
* <td rowspan="4" style="text-align: center">V</td>
|
|
* <td style="text-align: center">1</td>
|
|
* <td>uslax</td>
|
|
* <td>The short time zone ID.
|
|
* Where that is unavailable, the special short time zone ID <i>unk</i> (Unknown Zone) is used.<br>
|
|
* <i><b>Note</b>: This specifier was originally used for a variant of the short specific non-location format,
|
|
* but it was deprecated in the later version of the LDML specification. In CLDR 23/ICU 51, the definition of
|
|
* the specifier was changed to designate a short time zone ID.</i></td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">2</td>
|
|
* <td>America/Los_Angeles</td>
|
|
* <td>The long time zone ID.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">3</td>
|
|
* <td>Los Angeles</td>
|
|
* <td>The exemplar city (location) for the time zone.
|
|
* Where that is unavailable, the localized exemplar city name for the special zone <i>Etc/Unknown</i> is used
|
|
* as the fallback (for example, "Unknown City"). </td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">4</td>
|
|
* <td>Los Angeles Time</td>
|
|
* <td>The <i>generic location format</i>.
|
|
* Where that is unavailable, falls back to the <i>long localized GMT format</i> ("OOOO";
|
|
* Note: Fallback is only necessary with a GMT-style Time Zone ID, like Etc/GMT-830.)<br>
|
|
* This is especially useful when presenting possible timezone choices for user selection,
|
|
* since the naming is more uniform than the "v" format.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td rowspan="5" style="text-align: center">X</td>
|
|
* <td style="text-align: center">1</td>
|
|
* <td>-08<br>
|
|
* +0530<br>
|
|
* Z</td>
|
|
* <td>The <i>ISO8601 basic format</i> with hours field and optional minutes field.
|
|
* The ISO8601 UTC indicator "Z" is used when local time offset is 0.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">2</td>
|
|
* <td>-0800<br>
|
|
* Z</td>
|
|
* <td>The <i>ISO8601 basic format</i> with hours and minutes fields.
|
|
* The ISO8601 UTC indicator "Z" is used when local time offset is 0.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">3</td>
|
|
* <td>-08:00<br>
|
|
* Z</td>
|
|
* <td>The <i>ISO8601 extended format</i> with hours and minutes fields.
|
|
* The ISO8601 UTC indicator "Z" is used when local time offset is 0.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">4</td>
|
|
* <td>-0800<br>
|
|
* -075258<br>
|
|
* Z</td>
|
|
* <td>The <i>ISO8601 basic format</i> with hours, minutes and optional seconds fields.
|
|
* (Note: The seconds field is not supported by the ISO8601 specification.)
|
|
* The ISO8601 UTC indicator "Z" is used when local time offset is 0.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">5</td>
|
|
* <td>-08:00<br>
|
|
* -07:52:58<br>
|
|
* Z</td>
|
|
* <td>The <i>ISO8601 extended format</i> with hours, minutes and optional seconds fields.
|
|
* (Note: The seconds field is not supported by the ISO8601 specification.)
|
|
* The ISO8601 UTC indicator "Z" is used when local time offset is 0.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td rowspan="5" style="text-align: center">x</td>
|
|
* <td style="text-align: center">1</td>
|
|
* <td>-08<br>
|
|
* +0530</td>
|
|
* <td>The <i>ISO8601 basic format</i> with hours field and optional minutes field.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">2</td>
|
|
* <td>-0800</td>
|
|
* <td>The <i>ISO8601 basic format</i> with hours and minutes fields.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">3</td>
|
|
* <td>-08:00</td>
|
|
* <td>The <i>ISO8601 extended format</i> with hours and minutes fields.</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">4</td>
|
|
* <td>-0800<br>
|
|
* -075258</td>
|
|
* <td>The <i>ISO8601 basic format</i> with hours, minutes and optional seconds fields.
|
|
* (Note: The seconds field is not supported by the ISO8601 specification.)</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td style="text-align: center">5</td>
|
|
* <td>-08:00<br>
|
|
* -07:52:58</td>
|
|
* <td>The <i>ISO8601 extended format</i> with hours, minutes and optional seconds fields.
|
|
* (Note: The seconds field is not supported by the ISO8601 specification.)</td>
|
|
* </tr>
|
|
* </table>
|
|
*
|
|
* <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 failing
|
|
* UErrorCode result during formatting or parsing.
|
|
* <P>
|
|
* Examples using the US locale:
|
|
* <pre>
|
|
* \code
|
|
* 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" ->> 1996.July.10 AD 12:08 PM
|
|
* \endcode
|
|
* </pre>
|
|
* Code Sample:
|
|
* <pre>
|
|
* \code
|
|
* UErrorCode success = U_ZERO_ERROR;
|
|
* 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);
|
|
*
|
|
* // Format the current time.
|
|
* SimpleDateFormat* formatter
|
|
* = new SimpleDateFormat ("yyyy.MM.dd G 'at' hh:mm:ss a zzz", success );
|
|
* GregorianCalendar cal(success);
|
|
* UDate currentTime_1 = cal.getTime(success);
|
|
* FieldPosition fp(FieldPosition::DONT_CARE);
|
|
* UnicodeString dateString;
|
|
* formatter->format( currentTime_1, dateString, fp );
|
|
* cout << "result: " << dateString << endl;
|
|
*
|
|
* // Parse the previous string back into a Date.
|
|
* ParsePosition pp(0);
|
|
* UDate currentTime_2 = formatter->parse(dateString, pp );
|
|
* \endcode
|
|
* </pre>
|
|
* In the above example, the time value "currentTime_2" obtained from parsing
|
|
* will be equal to currentTime_1. 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 ("y" or "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
|
|
* <code>Unicode::isDigit()</code>, 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 (for the
|
|
* Gregorian calendar), using the same pattern, as Jan 2, 3 AD. Likewise (but
|
|
* only in lenient parse mode, the default) "01/02/-3" is parsed as Jan 2, 4 BC.
|
|
*
|
|
* <p>
|
|
* If the year pattern has more than 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, SimpleDateFormat uses 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 timezone.
|
|
* There is one common number format to handle all the numbers; the digit count
|
|
* is handled programmatically according to the pattern.
|
|
*
|
|
* <p><em>User subclasses are not supported.</em> While clients may write
|
|
* subclasses, such code will not necessarily work and will not be
|
|
* guaranteed to work stably from release to release.
|
|
*/
|
|
class U_I18N_API SimpleDateFormat: public DateFormat {
|
|
public:
|
|
/**
|
|
* Construct a SimpleDateFormat using the default pattern for the default
|
|
* locale.
|
|
* <P>
|
|
* [Note:] Not all locales support SimpleDateFormat; for full generality,
|
|
* use the factory methods in the DateFormat class.
|
|
* @param status Output param set to success/failure code.
|
|
* @stable ICU 2.0
|
|
*/
|
|
SimpleDateFormat(UErrorCode& status);
|
|
|
|
/**
|
|
* Construct a SimpleDateFormat using the given pattern and the default locale.
|
|
* The locale is used to obtain the symbols used in formatting (e.g., the
|
|
* names of the months), but not to provide the pattern.
|
|
* <P>
|
|
* [Note:] Not all locales support SimpleDateFormat; for full generality,
|
|
* use the factory methods in the DateFormat class.
|
|
* @param pattern the pattern for the format.
|
|
* @param status Output param set to success/failure code.
|
|
* @stable ICU 2.0
|
|
*/
|
|
SimpleDateFormat(const UnicodeString& pattern,
|
|
UErrorCode& status);
|
|
|
|
/**
|
|
* Construct a SimpleDateFormat using the given pattern, numbering system override, and the default locale.
|
|
* The locale is used to obtain the symbols used in formatting (e.g., the
|
|
* names of the months), but not to provide the pattern.
|
|
* <P>
|
|
* A numbering system override is a string containing either the name of a known numbering system,
|
|
* or a set of field and numbering system pairs that specify which fields are to be formattied with
|
|
* the alternate numbering system. For example, to specify that all numeric fields in the specified
|
|
* date or time pattern are to be rendered using Thai digits, simply specify the numbering system override
|
|
* as "thai". To specify that just the year portion of the date be formatted using Hebrew numbering,
|
|
* use the override string "y=hebrew". Numbering system overrides can be combined using a semi-colon
|
|
* character in the override string, such as "d=decimal;M=arabic;y=hebrew", etc.
|
|
*
|
|
* <P>
|
|
* [Note:] Not all locales support SimpleDateFormat; for full generality,
|
|
* use the factory methods in the DateFormat class.
|
|
* @param pattern the pattern for the format.
|
|
* @param override the override string.
|
|
* @param status Output param set to success/failure code.
|
|
* @stable ICU 4.2
|
|
*/
|
|
SimpleDateFormat(const UnicodeString& pattern,
|
|
const UnicodeString& override,
|
|
UErrorCode& status);
|
|
|
|
/**
|
|
* Construct a SimpleDateFormat using the given pattern and locale.
|
|
* The locale is used to obtain the symbols used in formatting (e.g., the
|
|
* names of the months), but not to provide the pattern.
|
|
* <P>
|
|
* [Note:] Not all locales support SimpleDateFormat; for full generality,
|
|
* use the factory methods in the DateFormat class.
|
|
* @param pattern the pattern for the format.
|
|
* @param locale the given locale.
|
|
* @param status Output param set to success/failure code.
|
|
* @stable ICU 2.0
|
|
*/
|
|
SimpleDateFormat(const UnicodeString& pattern,
|
|
const Locale& locale,
|
|
UErrorCode& status);
|
|
|
|
/**
|
|
* Construct a SimpleDateFormat using the given pattern, numbering system override, and locale.
|
|
* The locale is used to obtain the symbols used in formatting (e.g., the
|
|
* names of the months), but not to provide the pattern.
|
|
* <P>
|
|
* A numbering system override is a string containing either the name of a known numbering system,
|
|
* or a set of field and numbering system pairs that specify which fields are to be formattied with
|
|
* the alternate numbering system. For example, to specify that all numeric fields in the specified
|
|
* date or time pattern are to be rendered using Thai digits, simply specify the numbering system override
|
|
* as "thai". To specify that just the year portion of the date be formatted using Hebrew numbering,
|
|
* use the override string "y=hebrew". Numbering system overrides can be combined using a semi-colon
|
|
* character in the override string, such as "d=decimal;M=arabic;y=hebrew", etc.
|
|
* <P>
|
|
* [Note:] Not all locales support SimpleDateFormat; for full generality,
|
|
* use the factory methods in the DateFormat class.
|
|
* @param pattern the pattern for the format.
|
|
* @param override the numbering system override.
|
|
* @param locale the given locale.
|
|
* @param status Output param set to success/failure code.
|
|
* @stable ICU 4.2
|
|
*/
|
|
SimpleDateFormat(const UnicodeString& pattern,
|
|
const UnicodeString& override,
|
|
const Locale& locale,
|
|
UErrorCode& status);
|
|
|
|
/**
|
|
* Construct a SimpleDateFormat using the given pattern and locale-specific
|
|
* symbol data. The formatter takes ownership of the DateFormatSymbols object;
|
|
* the caller is no longer responsible for deleting it.
|
|
* @param pattern the given pattern for the format.
|
|
* @param formatDataToAdopt the symbols to be adopted.
|
|
* @param status Output param set to success/faulure code.
|
|
* @stable ICU 2.0
|
|
*/
|
|
SimpleDateFormat(const UnicodeString& pattern,
|
|
DateFormatSymbols* formatDataToAdopt,
|
|
UErrorCode& status);
|
|
|
|
/**
|
|
* Construct a SimpleDateFormat using the given pattern and locale-specific
|
|
* symbol data. The DateFormatSymbols object is NOT adopted; the caller
|
|
* remains responsible for deleting it.
|
|
* @param pattern the given pattern for the format.
|
|
* @param formatData the formatting symbols to be use.
|
|
* @param status Output param set to success/faulure code.
|
|
* @stable ICU 2.0
|
|
*/
|
|
SimpleDateFormat(const UnicodeString& pattern,
|
|
const DateFormatSymbols& formatData,
|
|
UErrorCode& status);
|
|
|
|
/**
|
|
* Copy constructor.
|
|
* @stable ICU 2.0
|
|
*/
|
|
SimpleDateFormat(const SimpleDateFormat&);
|
|
|
|
/**
|
|
* Assignment operator.
|
|
* @stable ICU 2.0
|
|
*/
|
|
SimpleDateFormat& operator=(const SimpleDateFormat&);
|
|
|
|
/**
|
|
* Destructor.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual ~SimpleDateFormat();
|
|
|
|
/**
|
|
* Clone this Format object polymorphically. The caller owns the result and
|
|
* should delete it when done.
|
|
* @return A copy of the object.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual Format* clone(void) const;
|
|
|
|
/**
|
|
* Return true if the given Format objects are semantically equal. Objects
|
|
* of different subclasses are considered unequal.
|
|
* @param other the object to be compared with.
|
|
* @return true if the given Format objects are semantically equal.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UBool operator==(const Format& other) const;
|
|
|
|
|
|
using DateFormat::format;
|
|
|
|
/**
|
|
* Format a date or time, which is the standard millis since 24:00 GMT, Jan
|
|
* 1, 1970. Overrides DateFormat pure virtual method.
|
|
* <P>
|
|
* Example: using the US locale: "yyyy.MM.dd e 'at' HH:mm:ss zzz" ->>
|
|
* 1996.07.10 AD at 15:08:56 PDT
|
|
*
|
|
* @param cal Calendar set to the date and time to be formatted
|
|
* into a date/time string.
|
|
* @param appendTo Output parameter to receive result.
|
|
* Result is appended to existing contents.
|
|
* @param pos The formatting position. On input: an alignment field,
|
|
* if desired. On output: the offsets of the alignment field.
|
|
* @return Reference to 'appendTo' parameter.
|
|
* @stable ICU 2.1
|
|
*/
|
|
virtual UnicodeString& format( Calendar& cal,
|
|
UnicodeString& appendTo,
|
|
FieldPosition& pos) const;
|
|
|
|
/**
|
|
* Format a date or time, which is the standard millis since 24:00 GMT, Jan
|
|
* 1, 1970. Overrides DateFormat pure virtual method.
|
|
* <P>
|
|
* Example: using the US locale: "yyyy.MM.dd e 'at' HH:mm:ss zzz" ->>
|
|
* 1996.07.10 AD at 15:08:56 PDT
|
|
*
|
|
* @param cal Calendar set to the date and time to be formatted
|
|
* into a date/time string.
|
|
* @param appendTo Output parameter to receive result.
|
|
* Result is appended to existing contents.
|
|
* @param posIter On return, can be used to iterate over positions
|
|
* of fields generated by this format call. Field values
|
|
* are defined in UDateFormatField.
|
|
* @param status Input/output param set to success/failure code.
|
|
* @return Reference to 'appendTo' parameter.
|
|
* @stable ICU 4.4
|
|
*/
|
|
virtual UnicodeString& format( Calendar& cal,
|
|
UnicodeString& appendTo,
|
|
FieldPositionIterator* posIter,
|
|
UErrorCode& status) const;
|
|
|
|
using DateFormat::parse;
|
|
|
|
/**
|
|
* Parse a date/time string beginning at the given parse position. For
|
|
* example, a time text "07/10/96 4:5 PM, PDT" will be parsed into a Date
|
|
* that is equivalent to Date(837039928046).
|
|
* <P>
|
|
* By default, parsing is lenient: If the input is not in the form used by
|
|
* this object's format method but can still be parsed as a date, then the
|
|
* parse succeeds. Clients may insist on strict adherence to the format by
|
|
* calling setLenient(false).
|
|
* @see DateFormat::setLenient(boolean)
|
|
*
|
|
* @param text The date/time string to be parsed
|
|
* @param cal A Calendar set on input to the date and time to be used for
|
|
* missing values in the date/time string being parsed, and set
|
|
* on output to the parsed date/time. When the calendar type is
|
|
* different from the internal calendar held by this SimpleDateFormat
|
|
* instance, the internal calendar will be cloned to a work
|
|
* calendar set to the same milliseconds and time zone as the
|
|
* cal parameter, field values will be parsed based on the work
|
|
* calendar, then the result (milliseconds and time zone) will
|
|
* be set in this calendar.
|
|
* @param pos On input, the position at which to start parsing; on
|
|
* output, the position at which parsing terminated, or the
|
|
* start position if the parse failed.
|
|
* @stable ICU 2.1
|
|
*/
|
|
virtual void parse( const UnicodeString& text,
|
|
Calendar& cal,
|
|
ParsePosition& pos) const;
|
|
|
|
|
|
/**
|
|
* Set the start UDate used to interpret two-digit year strings.
|
|
* When dates are parsed having 2-digit year strings, they are placed within
|
|
* a assumed range of 100 years starting on the two digit start date. For
|
|
* example, the string "24-Jan-17" may be in the year 1817, 1917, 2017, or
|
|
* some other year. SimpleDateFormat chooses a year so that the resultant
|
|
* date is on or after the two digit start date and within 100 years of the
|
|
* two digit start date.
|
|
* <P>
|
|
* By default, the two digit start date is set to 80 years before the current
|
|
* time at which a SimpleDateFormat object is created.
|
|
* @param d start UDate used to interpret two-digit year strings.
|
|
* @param status Filled in with U_ZERO_ERROR if the parse was successful, and with
|
|
* an error value if there was a parse error.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual void set2DigitYearStart(UDate d, UErrorCode& status);
|
|
|
|
/**
|
|
* Get the start UDate used to interpret two-digit year strings.
|
|
* When dates are parsed having 2-digit year strings, they are placed within
|
|
* a assumed range of 100 years starting on the two digit start date. For
|
|
* example, the string "24-Jan-17" may be in the year 1817, 1917, 2017, or
|
|
* some other year. SimpleDateFormat chooses a year so that the resultant
|
|
* date is on or after the two digit start date and within 100 years of the
|
|
* two digit start date.
|
|
* <P>
|
|
* By default, the two digit start date is set to 80 years before the current
|
|
* time at which a SimpleDateFormat object is created.
|
|
* @param status Filled in with U_ZERO_ERROR if the parse was successful, and with
|
|
* an error value if there was a parse error.
|
|
* @stable ICU 2.0
|
|
*/
|
|
UDate get2DigitYearStart(UErrorCode& status) const;
|
|
|
|
/**
|
|
* Return a pattern string describing this date format.
|
|
* @param result Output param to receive the pattern.
|
|
* @return A reference to 'result'.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UnicodeString& toPattern(UnicodeString& result) const;
|
|
|
|
/**
|
|
* Return a localized pattern string describing this date format.
|
|
* In most cases, this will return the same thing as toPattern(),
|
|
* but a locale can specify characters to use in pattern descriptions
|
|
* in place of the ones described in this class's class documentation.
|
|
* (Presumably, letters that would be more mnemonic in that locale's
|
|
* language.) This function would produce a pattern using those
|
|
* letters.
|
|
* <p>
|
|
* <b>Note:</b> This implementation depends on 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
|
|
* toPattern().
|
|
*
|
|
* @param result Receives the localized pattern.
|
|
* @param status Output param set to success/failure code on
|
|
* exit. If the pattern is invalid, this will be
|
|
* set to a failure result.
|
|
* @return A reference to 'result'.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UnicodeString& toLocalizedPattern(UnicodeString& result,
|
|
UErrorCode& status) const;
|
|
|
|
/**
|
|
* Apply the given unlocalized pattern string to this date format.
|
|
* (i.e., after this call, this formatter will format dates according to
|
|
* the new pattern)
|
|
*
|
|
* @param pattern The pattern to be applied.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual void applyPattern(const UnicodeString& pattern);
|
|
|
|
/**
|
|
* Apply the given localized pattern string to this date format.
|
|
* (see toLocalizedPattern() for more information on localized patterns.)
|
|
*
|
|
* @param pattern The localized pattern to be applied.
|
|
* @param status Output param set to success/failure code on
|
|
* exit. If the pattern is invalid, this will be
|
|
* set to a failure result.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual void applyLocalizedPattern(const UnicodeString& pattern,
|
|
UErrorCode& status);
|
|
|
|
/**
|
|
* Gets the date/time formatting symbols (this is an object carrying
|
|
* the various strings and other symbols used in formatting: e.g., month
|
|
* names and abbreviations, time zone names, AM/PM strings, etc.)
|
|
* @return a copy of the date-time formatting data associated
|
|
* with this date-time formatter.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual const DateFormatSymbols* getDateFormatSymbols(void) const;
|
|
|
|
/**
|
|
* Set the date/time formatting symbols. The caller no longer owns the
|
|
* DateFormatSymbols object and should not delete it after making this call.
|
|
* @param newFormatSymbols the given date-time formatting symbols to copy.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual void adoptDateFormatSymbols(DateFormatSymbols* newFormatSymbols);
|
|
|
|
/**
|
|
* Set the date/time formatting data.
|
|
* @param newFormatSymbols the given date-time formatting symbols to copy.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual void setDateFormatSymbols(const DateFormatSymbols& newFormatSymbols);
|
|
|
|
/**
|
|
* Return the class ID for this class. This is useful only for comparing to
|
|
* a return value from getDynamicClassID(). For example:
|
|
* <pre>
|
|
* . Base* polymorphic_pointer = createPolymorphicObject();
|
|
* . if (polymorphic_pointer->getDynamicClassID() ==
|
|
* . erived::getStaticClassID()) ...
|
|
* </pre>
|
|
* @return The class ID for all objects of this class.
|
|
* @stable ICU 2.0
|
|
*/
|
|
static UClassID U_EXPORT2 getStaticClassID(void);
|
|
|
|
/**
|
|
* Returns a unique class ID POLYMORPHICALLY. Pure virtual override. This
|
|
* method is to implement a simple version of RTTI, since not all C++
|
|
* compilers support genuine RTTI. Polymorphic operator==() and clone()
|
|
* methods call this method.
|
|
*
|
|
* @return The class ID for this object. All objects of a
|
|
* given class have the same class ID. Objects of
|
|
* other classes have different class IDs.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual UClassID getDynamicClassID(void) const;
|
|
|
|
/**
|
|
* Set the calendar to be used by this date format. Initially, the default
|
|
* calendar for the specified or default locale is used. The caller should
|
|
* not delete the Calendar object after it is adopted by this call.
|
|
* Adopting a new calendar will change to the default symbols.
|
|
*
|
|
* @param calendarToAdopt Calendar object to be adopted.
|
|
* @stable ICU 2.0
|
|
*/
|
|
virtual void adoptCalendar(Calendar* calendarToAdopt);
|
|
|
|
/* Cannot use #ifndef U_HIDE_INTERNAL_API for the following methods since they are virtual */
|
|
/**
|
|
* Sets the TimeZoneFormat to be used by this date/time formatter.
|
|
* The caller should not delete the TimeZoneFormat object after
|
|
* it is adopted by this call.
|
|
* @param timeZoneFormatToAdopt The TimeZoneFormat object to be adopted.
|
|
* @internal ICU 49 technology preview
|
|
*/
|
|
virtual void adoptTimeZoneFormat(TimeZoneFormat* timeZoneFormatToAdopt);
|
|
|
|
/**
|
|
* Sets the TimeZoneFormat to be used by this date/time formatter.
|
|
* @param newTimeZoneFormat The TimeZoneFormat object to copy.
|
|
* @internal ICU 49 technology preview
|
|
*/
|
|
virtual void setTimeZoneFormat(const TimeZoneFormat& newTimeZoneFormat);
|
|
|
|
/**
|
|
* Gets the time zone format object associated with this date/time formatter.
|
|
* @return the time zone format associated with this date/time formatter.
|
|
* @internal ICU 49 technology preview
|
|
*/
|
|
virtual const TimeZoneFormat* getTimeZoneFormat(void) const;
|
|
|
|
/**
|
|
* Set a particular UDisplayContext value in the formatter, such as
|
|
* UDISPCTX_CAPITALIZATION_FOR_STANDALONE. Note: For getContext, see
|
|
* DateFormat.
|
|
* @param value The UDisplayContext value to set.
|
|
* @param status Input/output status. If at entry this indicates a failure
|
|
* status, the function will do nothing; otherwise this will be
|
|
* updated with any new status from the function.
|
|
* @stable ICU 53
|
|
*/
|
|
virtual void setContext(UDisplayContext value, UErrorCode& status);
|
|
|
|
/**
|
|
* Overrides base class method and
|
|
* This method clears per field NumberFormat instances
|
|
* previously set by {@see adoptNumberFormat(const UnicodeString&, NumberFormat*, UErrorCode)}
|
|
* @param formatToAdopt the NumbeferFormat used
|
|
* @stable ICU 54
|
|
*/
|
|
void adoptNumberFormat(NumberFormat *formatToAdopt);
|
|
|
|
/**
|
|
* 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: "yM"(year and month)
|
|
* Note:
|
|
* 1 symbol field is enough for multiple symbol field (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)
|
|
* Per field NumberFormat can also be cleared in {@see DateFormat::setNumberFormat(const NumberFormat& newNumberFormat)}
|
|
*
|
|
* @param fields the fields to override(like y)
|
|
* @param formatToAdopt the NumbeferFormat used
|
|
* @param status Receives a status code, which will be U_ZERO_ERROR
|
|
* if the operation succeeds.
|
|
* @stable ICU 54
|
|
*/
|
|
void adoptNumberFormat(const UnicodeString& fields, NumberFormat *formatToAdopt, UErrorCode &status);
|
|
|
|
/**
|
|
* Get the numbering system to be used for a particular field.
|
|
* @param field The UDateFormatField to get
|
|
* @stable ICU 54
|
|
*/
|
|
const NumberFormat * getNumberFormatForField(char16_t field) const;
|
|
|
|
#ifndef U_HIDE_INTERNAL_API
|
|
/**
|
|
* This is for ICU internal use only. Please do not use.
|
|
* 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.
|
|
* @internal ICU 4.0
|
|
*/
|
|
UBool isFieldUnitIgnored(UCalendarDateFields field) const;
|
|
|
|
|
|
/**
|
|
* This is for ICU internal use only. Please do not use.
|
|
* 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.
|
|
* @internal ICU 4.0
|
|
*/
|
|
static UBool isFieldUnitIgnored(const UnicodeString& pattern,
|
|
UCalendarDateFields field);
|
|
|
|
/**
|
|
* This is for ICU internal use only. Please do not use.
|
|
* Get the locale of this simple date formatter.
|
|
* It is used in DateIntervalFormat.
|
|
*
|
|
* @return locale in this simple date formatter
|
|
* @internal ICU 4.0
|
|
*/
|
|
const Locale& getSmpFmtLocale(void) const;
|
|
#endif /* U_HIDE_INTERNAL_API */
|
|
|
|
private:
|
|
friend class DateFormat;
|
|
|
|
void initializeDefaultCentury(void);
|
|
|
|
void initializeBooleanAttributes(void);
|
|
|
|
SimpleDateFormat(); // default constructor not implemented
|
|
|
|
/**
|
|
* Used by the DateFormat factory methods to construct a SimpleDateFormat.
|
|
* @param timeStyle the time style.
|
|
* @param dateStyle the date style.
|
|
* @param locale the given locale.
|
|
* @param status Output param set to success/failure code on
|
|
* exit.
|
|
*/
|
|
SimpleDateFormat(EStyle timeStyle, EStyle dateStyle, const Locale& locale, UErrorCode& status);
|
|
|
|
/**
|
|
* Construct a SimpleDateFormat for the given locale. If no resource data
|
|
* is available, create an object of last resort, using hard-coded strings.
|
|
* This is an internal method, called by DateFormat. It should never fail.
|
|
* @param locale the given locale.
|
|
* @param status Output param set to success/failure code on
|
|
* exit.
|
|
*/
|
|
SimpleDateFormat(const Locale& locale, UErrorCode& status); // Use default pattern
|
|
|
|
/**
|
|
* Hook called by format(... FieldPosition& ...) and format(...FieldPositionIterator&...)
|
|
*/
|
|
UnicodeString& _format(Calendar& cal, UnicodeString& appendTo, FieldPositionHandler& handler, UErrorCode& status) const;
|
|
|
|
/**
|
|
* Called by format() to format a single field.
|
|
*
|
|
* @param appendTo Output parameter to receive result.
|
|
* Result is appended to existing contents.
|
|
* @param ch The format character we encountered in the pattern.
|
|
* @param count Number of characters in the current pattern symbol (e.g.,
|
|
* "yyyy" in the pattern would result in a call to this function
|
|
* with ch equal to 'y' and count equal to 4)
|
|
* @param capitalizationContext Capitalization context for this date format.
|
|
* @param fieldNum Zero-based numbering of current field within the overall format.
|
|
* @param handler Records information about field positions.
|
|
* @param cal Calendar to use
|
|
* @param status Receives a status code, which will be U_ZERO_ERROR if the operation
|
|
* succeeds.
|
|
*/
|
|
void subFormat(UnicodeString &appendTo,
|
|
char16_t ch,
|
|
int32_t count,
|
|
UDisplayContext capitalizationContext,
|
|
int32_t fieldNum,
|
|
FieldPositionHandler& handler,
|
|
Calendar& cal,
|
|
UErrorCode& status) const; // in case of illegal argument
|
|
|
|
/**
|
|
* Used by subFormat() to format a numeric value.
|
|
* Appends to toAppendTo a string representation of "value"
|
|
* having a number of digits between "minDigits" and
|
|
* "maxDigits". Uses the DateFormat's NumberFormat.
|
|
*
|
|
* @param currentNumberFormat
|
|
* @param appendTo Output parameter to receive result.
|
|
* Formatted number is appended to existing contents.
|
|
* @param value Value to format.
|
|
* @param minDigits Minimum number of digits the result should have
|
|
* @param maxDigits Maximum number of digits the result should have
|
|
*/
|
|
void zeroPaddingNumber(const NumberFormat *currentNumberFormat,
|
|
UnicodeString &appendTo,
|
|
int32_t value,
|
|
int32_t minDigits,
|
|
int32_t maxDigits) const;
|
|
|
|
/**
|
|
* Return true if the given format character, occuring count
|
|
* times, represents a numeric field.
|
|
*/
|
|
static UBool isNumeric(char16_t formatChar, int32_t count);
|
|
|
|
/**
|
|
* Returns TRUE if the patternOffset is at the start of a numeric field.
|
|
*/
|
|
static UBool isAtNumericField(const UnicodeString &pattern, int32_t patternOffset);
|
|
|
|
/**
|
|
* Returns TRUE if the patternOffset is right after a non-numeric field.
|
|
*/
|
|
static UBool isAfterNonNumericField(const UnicodeString &pattern, int32_t patternOffset);
|
|
|
|
/**
|
|
* initializes fCalendar from parameters. Returns fCalendar as a convenience.
|
|
* @param adoptZone Zone to be adopted, or NULL for TimeZone::createDefault().
|
|
* @param locale Locale of the calendar
|
|
* @param status Error code
|
|
* @return the newly constructed fCalendar
|
|
*/
|
|
Calendar *initializeCalendar(TimeZone* adoptZone, const Locale& locale, UErrorCode& status);
|
|
|
|
/**
|
|
* Called by several of the constructors to load pattern data and formatting symbols
|
|
* out of a resource bundle and initialize the locale based on it.
|
|
* @param timeStyle The time style, as passed to DateFormat::createDateInstance().
|
|
* @param dateStyle The date style, as passed to DateFormat::createTimeInstance().
|
|
* @param locale The locale to load the patterns from.
|
|
* @param status Filled in with an error code if loading the data from the
|
|
* resources fails.
|
|
*/
|
|
void construct(EStyle timeStyle, EStyle dateStyle, const Locale& locale, UErrorCode& status);
|
|
|
|
/**
|
|
* Called by construct() and the various constructors to set up the SimpleDateFormat's
|
|
* Calendar and NumberFormat objects.
|
|
* @param locale The locale for which we want a Calendar and a NumberFormat.
|
|
* @param status Filled in with an error code if creating either subobject fails.
|
|
*/
|
|
void initialize(const Locale& locale, UErrorCode& status);
|
|
|
|
/**
|
|
* Private code-size reduction function used by subParse.
|
|
* @param text the time text being parsed.
|
|
* @param start where to start parsing.
|
|
* @param field the date field being parsed.
|
|
* @param stringArray the string array to parsed.
|
|
* @param stringArrayCount the size of the array.
|
|
* @param monthPattern pointer to leap month pattern, or NULL if none.
|
|
* @param cal a Calendar set to the date and time to be formatted
|
|
* into a date/time string.
|
|
* @return the new start position if matching succeeded; a negative number
|
|
* indicating matching failure, otherwise.
|
|
*/
|
|
int32_t matchString(const UnicodeString& text, int32_t start, UCalendarDateFields field,
|
|
const UnicodeString* stringArray, int32_t stringArrayCount,
|
|
const UnicodeString* monthPattern, Calendar& cal) const;
|
|
|
|
/**
|
|
* Private code-size reduction function used by subParse.
|
|
* @param text the time text being parsed.
|
|
* @param start where to start parsing.
|
|
* @param field the date field being parsed.
|
|
* @param stringArray the string array to parsed.
|
|
* @param stringArrayCount the size of the array.
|
|
* @param cal a Calendar set to the date and time to be formatted
|
|
* into a date/time string.
|
|
* @return the new start position if matching succeeded; a negative number
|
|
* indicating matching failure, otherwise.
|
|
*/
|
|
int32_t matchQuarterString(const UnicodeString& text, int32_t start, UCalendarDateFields field,
|
|
const UnicodeString* stringArray, int32_t stringArrayCount, Calendar& cal) const;
|
|
|
|
/**
|
|
* Used by subParse() to match localized day period strings.
|
|
*/
|
|
int32_t matchDayPeriodStrings(const UnicodeString& text, int32_t start,
|
|
const UnicodeString* stringArray, int32_t stringArrayCount,
|
|
int32_t &dayPeriod) const;
|
|
|
|
/**
|
|
* Private function used by subParse to match literal pattern text.
|
|
*
|
|
* @param pattern the pattern string
|
|
* @param patternOffset the starting offset into the pattern text. On
|
|
* outupt will be set the offset of the first non-literal character in the pattern
|
|
* @param text the text being parsed
|
|
* @param textOffset the starting offset into the text. On output
|
|
* will be set to the offset of the character after the match
|
|
* @param whitespaceLenient <code>TRUE</code> if whitespace parse is lenient, <code>FALSE</code> otherwise.
|
|
* @param partialMatchLenient <code>TRUE</code> if partial match parse is lenient, <code>FALSE</code> otherwise.
|
|
* @param oldLeniency <code>TRUE</code> if old leniency control is lenient, <code>FALSE</code> otherwise.
|
|
*
|
|
* @return <code>TRUE</code> if the literal text could be matched, <code>FALSE</code> otherwise.
|
|
*/
|
|
static UBool matchLiterals(const UnicodeString &pattern, int32_t &patternOffset,
|
|
const UnicodeString &text, int32_t &textOffset,
|
|
UBool whitespaceLenient, UBool partialMatchLenient, UBool oldLeniency);
|
|
|
|
/**
|
|
* Private member function that converts the parsed date strings into
|
|
* timeFields. Returns -start (for ParsePosition) if failed.
|
|
* @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 count is strictly obeyed.
|
|
* @param allowNegative
|
|
* @param ambiguousYear If true then the two-digit year == the default start year.
|
|
* @param saveHebrewMonth Used to hang onto month until year is known.
|
|
* @param cal a Calendar set to the date and time to be formatted
|
|
* into a date/time string.
|
|
* @param patLoc
|
|
* @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.
|
|
*/
|
|
int32_t subParse(const UnicodeString& text, int32_t& start, char16_t ch, int32_t count,
|
|
UBool obeyCount, UBool allowNegative, UBool ambiguousYear[], int32_t& saveHebrewMonth, Calendar& cal,
|
|
int32_t patLoc, MessageFormat * numericLeapMonthFormatter, UTimeZoneFormatTimeType *tzTimeType,
|
|
int32_t *dayPeriod=NULL) const;
|
|
|
|
void parseInt(const UnicodeString& text,
|
|
Formattable& number,
|
|
ParsePosition& pos,
|
|
UBool allowNegative,
|
|
const NumberFormat *fmt) const;
|
|
|
|
void parseInt(const UnicodeString& text,
|
|
Formattable& number,
|
|
int32_t maxDigits,
|
|
ParsePosition& pos,
|
|
UBool allowNegative,
|
|
const NumberFormat *fmt) const;
|
|
|
|
int32_t checkIntSuffix(const UnicodeString& text, int32_t start,
|
|
int32_t patLoc, UBool isNegative) const;
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
int32_t countDigits(const UnicodeString& text, int32_t start, int32_t end) const;
|
|
|
|
/**
|
|
* Translate a pattern, mapping each character in the from string to the
|
|
* corresponding character in the to string. Return an error if the original
|
|
* pattern contains an unmapped character, or if a quote is unmatched.
|
|
* Quoted (single quotes only) material is not translated.
|
|
* @param originalPattern the original pattern.
|
|
* @param translatedPattern Output param to receive the translited pattern.
|
|
* @param from the characters to be translited from.
|
|
* @param to the characters to be translited to.
|
|
* @param status Receives a status code, which will be U_ZERO_ERROR
|
|
* if the operation succeeds.
|
|
*/
|
|
static void translatePattern(const UnicodeString& originalPattern,
|
|
UnicodeString& translatedPattern,
|
|
const UnicodeString& from,
|
|
const UnicodeString& to,
|
|
UErrorCode& status);
|
|
|
|
/**
|
|
* Sets the starting date of the 100-year window that dates with 2-digit years
|
|
* are considered to fall within.
|
|
* @param startDate the start date
|
|
* @param status Receives a status code, which will be U_ZERO_ERROR
|
|
* if the operation succeeds.
|
|
*/
|
|
void parseAmbiguousDatesAsAfter(UDate startDate, UErrorCode& status);
|
|
|
|
/**
|
|
* Return the length matched by the given affix, or -1 if none.
|
|
* Runs of white space in the affix, match runs of white space in
|
|
* the input.
|
|
* @param affix pattern string, taken as a literal
|
|
* @param input input text
|
|
* @param pos offset into input at which to begin matching
|
|
* @return length of input that matches, or -1 if match failure
|
|
*/
|
|
int32_t compareSimpleAffix(const UnicodeString& affix,
|
|
const UnicodeString& input,
|
|
int32_t pos) const;
|
|
|
|
/**
|
|
* Skip over a run of zero or more Pattern_White_Space characters at
|
|
* pos in text.
|
|
*/
|
|
int32_t skipPatternWhiteSpace(const UnicodeString& text, int32_t pos) const;
|
|
|
|
/**
|
|
* Skip over a run of zero or more isUWhiteSpace() characters at pos
|
|
* in text.
|
|
*/
|
|
int32_t skipUWhiteSpace(const UnicodeString& text, int32_t pos) const;
|
|
|
|
/**
|
|
* Initialize LocalizedNumberFormatter instances used for speedup.
|
|
*/
|
|
void initFastNumberFormatters(UErrorCode& status);
|
|
|
|
/**
|
|
* Delete the LocalizedNumberFormatter instances used for speedup.
|
|
*/
|
|
void freeFastNumberFormatters();
|
|
|
|
/**
|
|
* Initialize NumberFormat instances used for numbering system overrides.
|
|
*/
|
|
void initNumberFormatters(const Locale &locale,UErrorCode &status);
|
|
|
|
/**
|
|
* Parse the given override string and set up structures for number formats
|
|
*/
|
|
void processOverrideString(const Locale &locale, const UnicodeString &str, int8_t type, UErrorCode &status);
|
|
|
|
/**
|
|
* Used to map pattern characters to Calendar field identifiers.
|
|
*/
|
|
static const UCalendarDateFields fgPatternIndexToCalendarField[];
|
|
|
|
/**
|
|
* Map index into pattern character string to DateFormat field number
|
|
*/
|
|
static const UDateFormatField fgPatternIndexToDateFormatField[];
|
|
|
|
/**
|
|
* Lazy TimeZoneFormat instantiation, semantically const
|
|
*/
|
|
TimeZoneFormat *tzFormat(UErrorCode &status) const;
|
|
|
|
const NumberFormat* getNumberFormatByIndex(UDateFormatField index) const;
|
|
|
|
/**
|
|
* Used to map Calendar field to field level.
|
|
* The larger the level, the smaller the field unit.
|
|
* For example, UCAL_ERA level is 0, UCAL_YEAR level is 10,
|
|
* UCAL_MONTH level is 20.
|
|
*/
|
|
static const int32_t fgCalendarFieldToLevel[];
|
|
|
|
/**
|
|
* Map calendar field letter into calendar field level.
|
|
*/
|
|
static int32_t getLevelFromChar(char16_t ch);
|
|
|
|
/**
|
|
* Tell if a character can be used to define a field in a format string.
|
|
*/
|
|
static UBool isSyntaxChar(char16_t ch);
|
|
|
|
/**
|
|
* The formatting pattern for this formatter.
|
|
*/
|
|
UnicodeString fPattern;
|
|
|
|
/**
|
|
* The numbering system override for dates.
|
|
*/
|
|
UnicodeString fDateOverride;
|
|
|
|
/**
|
|
* The numbering system override for times.
|
|
*/
|
|
UnicodeString fTimeOverride;
|
|
|
|
|
|
/**
|
|
* The original locale used (for reloading symbols)
|
|
*/
|
|
Locale fLocale;
|
|
|
|
/**
|
|
* A pointer to an object containing the strings to use in formatting (e.g.,
|
|
* month and day names, AM and PM strings, time zone names, etc.)
|
|
*/
|
|
DateFormatSymbols* fSymbols; // Owned
|
|
|
|
/**
|
|
* The time zone formatter
|
|
*/
|
|
TimeZoneFormat* fTimeZoneFormat;
|
|
|
|
/**
|
|
* If dates have ambiguous years, we map them into the century starting
|
|
* at defaultCenturyStart, which may be any date. If defaultCenturyStart is
|
|
* set to SYSTEM_DEFAULT_CENTURY, which it is by default, then the system
|
|
* values are used. The instance values defaultCenturyStart and
|
|
* defaultCenturyStartYear are only used if explicitly set by the user
|
|
* through the API method parseAmbiguousDatesAsAfter().
|
|
*/
|
|
UDate fDefaultCenturyStart;
|
|
|
|
UBool fHasMinute;
|
|
UBool fHasSecond;
|
|
|
|
/**
|
|
* Sets fHasMinutes and fHasSeconds.
|
|
*/
|
|
void parsePattern();
|
|
|
|
/**
|
|
* See documentation for defaultCenturyStart.
|
|
*/
|
|
/*transient*/ int32_t fDefaultCenturyStartYear;
|
|
|
|
struct NSOverride : public UMemory {
|
|
const SharedNumberFormat *snf;
|
|
int32_t hash;
|
|
NSOverride *next;
|
|
void free();
|
|
NSOverride() : snf(NULL), hash(0), next(NULL) {
|
|
}
|
|
~NSOverride();
|
|
};
|
|
|
|
/**
|
|
* The number format in use for each date field. NULL means fall back
|
|
* to fNumberFormat in DateFormat.
|
|
*/
|
|
const SharedNumberFormat **fSharedNumberFormatters;
|
|
|
|
enum NumberFormatterKey {
|
|
SMPDTFMT_NF_1x10,
|
|
SMPDTFMT_NF_2x10,
|
|
SMPDTFMT_NF_3x10,
|
|
SMPDTFMT_NF_4x10,
|
|
SMPDTFMT_NF_2x2,
|
|
SMPDTFMT_NF_COUNT
|
|
};
|
|
|
|
/**
|
|
* Number formatters pre-allocated for fast performance on the most common integer lengths.
|
|
*/
|
|
const number::LocalizedNumberFormatter* fFastNumberFormatters[SMPDTFMT_NF_COUNT] = {};
|
|
|
|
UBool fHaveDefaultCentury;
|
|
|
|
BreakIterator* fCapitalizationBrkIter;
|
|
};
|
|
|
|
inline UDate
|
|
SimpleDateFormat::get2DigitYearStart(UErrorCode& /*status*/) const
|
|
{
|
|
return fDefaultCenturyStart;
|
|
}
|
|
|
|
U_NAMESPACE_END
|
|
|
|
#endif /* #if !UCONFIG_NO_FORMATTING */
|
|
|
|
#endif // _SMPDTFMT
|
|
//eof
|