1 /*
2 * Copyright (C) 1997-2012, International Business Machines Corporation and
3 * others. All Rights Reserved.
4 *******************************************************************************
5 *
6 * File SMPDTFMT.H
7 *
8 * Modification History:
9 *
10 * Date Name Description
11 * 02/19/97 aliu Converted from java.
12 * 07/09/97 helena Make ParsePosition into a class.
13 * 07/21/98 stephen Added GMT_PLUS, GMT_MINUS
14 * Changed setTwoDigitStartDate to set2DigitYearStart
15 * Changed getTwoDigitStartDate to get2DigitYearStart
16 * Removed subParseLong
17 * Removed getZoneIndex (added in DateFormatSymbols)
18 * 06/14/99 stephen Removed fgTimeZoneDataSuffix
19 * 10/14/99 aliu Updated class doc to describe 2-digit year parsing
20 * {j28 4182066}.
21 *******************************************************************************
22 */
23
24 #ifndef SMPDTFMT_H
25 #define SMPDTFMT_H
26
27 #include "unicode/utypes.h"
28
29 /**
30 * \file
31 * \brief C++ API: Format and parse dates in a language-independent manner.
32 */
33
34 #if !UCONFIG_NO_FORMATTING
35
36 #include "unicode/datefmt.h"
37 #include "unicode/udisplaycontext.h"
38
39 U_NAMESPACE_BEGIN
40
41 class DateFormatSymbols;
42 class DateFormat;
43 class MessageFormat;
44 class FieldPositionHandler;
45 class TimeZoneFormat;
46
47 /**
48 *
49 * SimpleDateFormat is a concrete class for formatting and parsing dates in a
50 * language-independent manner. It allows for formatting (millis -> text),
51 * parsing (text -> millis), and normalization. Formats/Parses a date or time,
52 * which is the standard milliseconds since 24:00 GMT, Jan 1, 1970.
53 * <P>
54 * Clients are encouraged to create a date-time formatter using DateFormat::getInstance(),
55 * getDateInstance(), getDateInstance(), or getDateTimeInstance() rather than
56 * explicitly constructing an instance of SimpleDateFormat. This way, the client
57 * is guaranteed to get an appropriate formatting pattern for whatever locale the
58 * program is running in. However, if the client needs something more unusual than
59 * the default patterns in the locales, he can construct a SimpleDateFormat directly
60 * and give it an appropriate pattern (or use one of the factory methods on DateFormat
61 * and modify the pattern after the fact with toPattern() and applyPattern().
62 * <P>
63 * Date/Time format syntax:
64 * <P>
65 * The date/time format is specified by means of a string time pattern. In this
66 * pattern, all ASCII letters are reserved as pattern letters, which are defined
67 * as the following:
68 * <pre>
69 * \code
70 * Symbol Meaning Presentation Example
71 * ------ ------- ------------ -------
72 * G era designator (Text) AD
73 * y year (Number) 1996
74 * Y year (week of year) (Number) 1997
75 * u extended year (Number) 4601
76 * U cyclic year name (Text,NumFallback) ren-chen (29)
77 * Q Quarter (Text & Number) Q2 & 02
78 * M month in year (Text & Number) July & 07
79 * d day in month (Number) 10
80 * h hour in am/pm (1~12) (Number) 12
81 * H hour in day (0~23) (Number) 0
82 * m minute in hour (Number) 30
83 * s second in minute (Number) 55
84 * S fractional second (Number) 978
85 * (maximum resolution of SSS; truncated if shorter, zero-padded if longer)
86 * E day of week (Text) Tuesday
87 * e day of week (local 1~7) (Text & Number) Tues & 2
88 * D day in year (Number) 189
89 * F day of week in month (Number) 2 (2nd Wed in July)
90 * w week in year (Number) 27
91 * W week in month (Number) 2
92 * a am/pm marker (Text) PM
93 * k hour in day (1~24) (Number) 24
94 * K hour in am/pm (0~11) (Number) 0
95 * z time zone (Text) PST
96 * zzzz time zone (Text) Pacific Standard Time
97 * Z time zone (RFC 822) (Number) -0800
98 * ZZZZ time zone (RFC 822) (Text & Number) GMT-08:00
99 * ZZZZZ time zone (ISO 8601) (Text & Number) -08:00 & Z
100 * v time zone (generic) (Text) PT
101 * vvvv time zone (generic) (Text) Pacific Time
102 * V time zone (abreviation) (Text) PST
103 * VVVV time zone (location) (Text) United States Time (Los Angeles)
104 * g Julian day (Number) 2451334
105 * A milliseconds in day (Number) 69540000
106 * q stand alone quarter (Text & Number) Q2 & 02
107 * L stand alone month (Text & Number) July & 07
108 * c stand alone day of week (Text & Number) Tuesday & 2
109 * ' escape for text (Delimiter) 'Date='
110 * '' single quote (Literal) 'o''clock'
111 * \endcode
112 * </pre>
113 * The count of pattern letters determine the format.
114 * <P>
115 * (Text): 4 or more, use full form, <4, use short or abbreviated form if it
116 * exists. (e.g., "EEEE" produces "Monday", "EEE" produces "Mon")
117 * <P>
118 * (Number): the minimum number of digits. Shorter numbers are zero-padded to
119 * this amount (e.g. if "m" produces "6", "mm" produces "06"). Year is handled
120 * specially; that is, if the count of 'y' is 2, the Year will be truncated to 2 digits.
121 * (e.g., if "yyyy" produces "1997", "yy" produces "97".)
122 * Unlike other fields, fractional seconds are padded on the right with zero.
123 * <P>
124 * (Text & Number): 3 or over, use text, otherwise use number. (e.g., "M" produces "1",
125 * "MM" produces "01", "MMM" produces "Jan", and "MMMM" produces "January".)
126 * <P>
127 * (Text,NumFallback): Behaves like Text if there is supporting data, like
128 * Number otherwise.
129 * <P>
130 * Any characters in the pattern that are not in the ranges of ['a'..'z'] and
131 * ['A'..'Z'] will be treated as quoted text. For instance, characters
132 * like ':', '.', ' ', '#' and '@' will appear in the resulting time text
133 * even they are not embraced within single quotes.
134 * <P>
135 * A pattern containing any invalid pattern letter will result in a failing
136 * UErrorCode result during formatting or parsing.
137 * <P>
138 * Examples using the US locale:
139 * <pre>
140 * \code
141 * Format Pattern Result
142 * -------------- -------
143 * "yyyy.MM.dd G 'at' HH:mm:ss vvvv" ->> 1996.07.10 AD at 15:08:56 Pacific Time
144 * "EEE, MMM d, ''yy" ->> Wed, July 10, '96
145 * "h:mm a" ->> 12:08 PM
146 * "hh 'o''clock' a, zzzz" ->> 12 o'clock PM, Pacific Daylight Time
147 * "K:mm a, vvv" ->> 0:00 PM, PT
148 * "yyyyy.MMMMM.dd GGG hh:mm aaa" ->> 1996.July.10 AD 12:08 PM
149 * \endcode
150 * </pre>
151 * Code Sample:
152 * <pre>
153 * \code
154 * UErrorCode success = U_ZERO_ERROR;
155 * SimpleTimeZone* pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, "PST");
156 * pdt->setStartRule( Calendar::APRIL, 1, Calendar::SUNDAY, 2*60*60*1000);
157 * pdt->setEndRule( Calendar::OCTOBER, -1, Calendar::SUNDAY, 2*60*60*1000);
158 *
159 * // Format the current time.
160 * SimpleDateFormat* formatter
161 * = new SimpleDateFormat ("yyyy.MM.dd G 'at' hh:mm:ss a zzz", success );
162 * GregorianCalendar cal(success);
163 * UDate currentTime_1 = cal.getTime(success);
164 * FieldPosition fp(0);
165 * UnicodeString dateString;
166 * formatter->format( currentTime_1, dateString, fp );
167 * cout << "result: " << dateString << endl;
168 *
169 * // Parse the previous string back into a Date.
170 * ParsePosition pp(0);
171 * UDate currentTime_2 = formatter->parse(dateString, pp );
172 * \endcode
173 * </pre>
174 * In the above example, the time value "currentTime_2" obtained from parsing
175 * will be equal to currentTime_1. However, they may not be equal if the am/pm
176 * marker 'a' is left out from the format pattern while the "hour in am/pm"
177 * pattern symbol is used. This information loss can happen when formatting the
178 * time in PM.
179 *
180 * <p>
181 * When parsing a date string using the abbreviated year pattern ("y" or "yy"),
182 * SimpleDateFormat must interpret the abbreviated year
183 * relative to some century. It does this by adjusting dates to be
184 * within 80 years before and 20 years after the time the SimpleDateFormat
185 * instance is created. For example, using a pattern of "MM/dd/yy" and a
186 * SimpleDateFormat instance created on Jan 1, 1997, the string
187 * "01/11/12" would be interpreted as Jan 11, 2012 while the string "05/04/64"
188 * would be interpreted as May 4, 1964.
189 * During parsing, only strings consisting of exactly two digits, as defined by
190 * <code>Unicode::isDigit()</code>, will be parsed into the default century.
191 * Any other numeric string, such as a one digit string, a three or more digit
192 * string, or a two digit string that isn't all digits (for example, "-1"), is
193 * interpreted literally. So "01/02/3" or "01/02/003" are parsed (for the
194 * Gregorian calendar), using the same pattern, as Jan 2, 3 AD. Likewise (but
195 * only in lenient parse mode, the default) "01/02/-3" is parsed as Jan 2, 4 BC.
196 *
197 * <p>
198 * If the year pattern has more than two 'y' characters, the year is
199 * interpreted literally, regardless of the number of digits. So using the
200 * pattern "MM/dd/yyyy", "01/11/12" parses to Jan 11, 12 A.D.
201 *
202 * <p>
203 * When numeric fields abut one another directly, with no intervening delimiter
204 * characters, they constitute a run of abutting numeric fields. Such runs are
205 * parsed specially. For example, the format "HHmmss" parses the input text
206 * "123456" to 12:34:56, parses the input text "12345" to 1:23:45, and fails to
207 * parse "1234". In other words, the leftmost field of the run is flexible,
208 * while the others keep a fixed width. If the parse fails anywhere in the run,
209 * then the leftmost field is shortened by one character, and the entire run is
210 * parsed again. This is repeated until either the parse succeeds or the
211 * leftmost field is one character in length. If the parse still fails at that
212 * point, the parse of the run fails.
213 *
214 * <P>
215 * For time zones that have no names, SimpleDateFormat uses strings GMT+hours:minutes or
216 * GMT-hours:minutes.
217 * <P>
218 * The calendar defines what is the first day of the week, the first week of the
219 * year, whether hours are zero based or not (0 vs 12 or 24), and the timezone.
220 * There is one common number format to handle all the numbers; the digit count
221 * is handled programmatically according to the pattern.
222 *
223 * <p><em>User subclasses are not supported.</em> While clients may write
224 * subclasses, such code will not necessarily work and will not be
225 * guaranteed to work stably from release to release.
226 */
227 class U_I18N_API SimpleDateFormat: public DateFormat {
228 public:
229 /**
230 * Construct a SimpleDateFormat using the default pattern for the default
231 * locale.
232 * <P>
233 * [Note:] Not all locales support SimpleDateFormat; for full generality,
234 * use the factory methods in the DateFormat class.
235 * @param status Output param set to success/failure code.
236 * @stable ICU 2.0
237 */
238 SimpleDateFormat(UErrorCode& status);
239
240 /**
241 * Construct a SimpleDateFormat using the given pattern and the default locale.
242 * The locale is used to obtain the symbols used in formatting (e.g., the
243 * names of the months), but not to provide the pattern.
244 * <P>
245 * [Note:] Not all locales support SimpleDateFormat; for full generality,
246 * use the factory methods in the DateFormat class.
247 * @param pattern the pattern for the format.
248 * @param status Output param set to success/failure code.
249 * @stable ICU 2.0
250 */
251 SimpleDateFormat(const UnicodeString& pattern,
252 UErrorCode& status);
253
254 /**
255 * Construct a SimpleDateFormat using the given pattern, numbering system override, and the default locale.
256 * The locale is used to obtain the symbols used in formatting (e.g., the
257 * names of the months), but not to provide the pattern.
258 * <P>
259 * A numbering system override is a string containing either the name of a known numbering system,
260 * or a set of field and numbering system pairs that specify which fields are to be formattied with
261 * the alternate numbering system. For example, to specify that all numeric fields in the specified
262 * date or time pattern are to be rendered using Thai digits, simply specify the numbering system override
263 * as "thai". To specify that just the year portion of the date be formatted using Hebrew numbering,
264 * use the override string "y=hebrew". Numbering system overrides can be combined using a semi-colon
265 * character in the override string, such as "d=decimal;M=arabic;y=hebrew", etc.
266 *
267 * <P>
268 * [Note:] Not all locales support SimpleDateFormat; for full generality,
269 * use the factory methods in the DateFormat class.
270 * @param pattern the pattern for the format.
271 * @param override the override string.
272 * @param status Output param set to success/failure code.
273 * @stable ICU 4.2
274 */
275 SimpleDateFormat(const UnicodeString& pattern,
276 const UnicodeString& override,
277 UErrorCode& status);
278
279 /**
280 * Construct a SimpleDateFormat using the given pattern and locale.
281 * The locale is used to obtain the symbols used in formatting (e.g., the
282 * names of the months), but not to provide the pattern.
283 * <P>
284 * [Note:] Not all locales support SimpleDateFormat; for full generality,
285 * use the factory methods in the DateFormat class.
286 * @param pattern the pattern for the format.
287 * @param locale the given locale.
288 * @param status Output param set to success/failure code.
289 * @stable ICU 2.0
290 */
291 SimpleDateFormat(const UnicodeString& pattern,
292 const Locale& locale,
293 UErrorCode& status);
294
295 /**
296 * Construct a SimpleDateFormat using the given pattern, numbering system override, and locale.
297 * The locale is used to obtain the symbols used in formatting (e.g., the
298 * names of the months), but not to provide the pattern.
299 * <P>
300 * A numbering system override is a string containing either the name of a known numbering system,
301 * or a set of field and numbering system pairs that specify which fields are to be formattied with
302 * the alternate numbering system. For example, to specify that all numeric fields in the specified
303 * date or time pattern are to be rendered using Thai digits, simply specify the numbering system override
304 * as "thai". To specify that just the year portion of the date be formatted using Hebrew numbering,
305 * use the override string "y=hebrew". Numbering system overrides can be combined using a semi-colon
306 * character in the override string, such as "d=decimal;M=arabic;y=hebrew", etc.
307 * <P>
308 * [Note:] Not all locales support SimpleDateFormat; for full generality,
309 * use the factory methods in the DateFormat class.
310 * @param pattern the pattern for the format.
311 * @param override the numbering system override.
312 * @param locale the given locale.
313 * @param status Output param set to success/failure code.
314 * @stable ICU 4.2
315 */
316 SimpleDateFormat(const UnicodeString& pattern,
317 const UnicodeString& override,
318 const Locale& locale,
319 UErrorCode& status);
320
321 /**
322 * Construct a SimpleDateFormat using the given pattern and locale-specific
323 * symbol data. The formatter takes ownership of the DateFormatSymbols object;
324 * the caller is no longer responsible for deleting it.
325 * @param pattern the given pattern for the format.
326 * @param formatDataToAdopt the symbols to be adopted.
327 * @param status Output param set to success/faulure code.
328 * @stable ICU 2.0
329 */
330 SimpleDateFormat(const UnicodeString& pattern,
331 DateFormatSymbols* formatDataToAdopt,
332 UErrorCode& status);
333
334 /**
335 * Construct a SimpleDateFormat using the given pattern and locale-specific
336 * symbol data. The DateFormatSymbols object is NOT adopted; the caller
337 * remains responsible for deleting it.
338 * @param pattern the given pattern for the format.
339 * @param formatData the formatting symbols to be use.
340 * @param status Output param set to success/faulure code.
341 * @stable ICU 2.0
342 */
343 SimpleDateFormat(const UnicodeString& pattern,
344 const DateFormatSymbols& formatData,
345 UErrorCode& status);
346
347 /**
348 * Copy constructor.
349 * @stable ICU 2.0
350 */
351 SimpleDateFormat(const SimpleDateFormat&);
352
353 /**
354 * Assignment operator.
355 * @stable ICU 2.0
356 */
357 SimpleDateFormat& operator=(const SimpleDateFormat&);
358
359 /**
360 * Destructor.
361 * @stable ICU 2.0
362 */
363 virtual ~SimpleDateFormat();
364
365 /**
366 * Clone this Format object polymorphically. The caller owns the result and
367 * should delete it when done.
368 * @return A copy of the object.
369 * @stable ICU 2.0
370 */
371 virtual Format* clone(void) const;
372
373 /**
374 * Return true if the given Format objects are semantically equal. Objects
375 * of different subclasses are considered unequal.
376 * @param other the object to be compared with.
377 * @return true if the given Format objects are semantically equal.
378 * @stable ICU 2.0
379 */
380 virtual UBool operator==(const Format& other) const;
381
382
383 using DateFormat::format;
384
385 /**
386 * Format a date or time, which is the standard millis since 24:00 GMT, Jan
387 * 1, 1970. Overrides DateFormat pure virtual method.
388 * <P>
389 * Example: using the US locale: "yyyy.MM.dd e 'at' HH:mm:ss zzz" ->>
390 * 1996.07.10 AD at 15:08:56 PDT
391 *
392 * @param cal Calendar set to the date and time to be formatted
393 * into a date/time string.
394 * @param appendTo Output parameter to receive result.
395 * Result is appended to existing contents.
396 * @param pos The formatting position. On input: an alignment field,
397 * if desired. On output: the offsets of the alignment field.
398 * @return Reference to 'appendTo' parameter.
399 * @stable ICU 2.1
400 */
401 virtual UnicodeString& format( Calendar& cal,
402 UnicodeString& appendTo,
403 FieldPosition& pos) const;
404
405 /**
406 * Format a date or time, which is the standard millis since 24:00 GMT, Jan
407 * 1, 1970. Overrides DateFormat pure virtual method.
408 * <P>
409 * Example: using the US locale: "yyyy.MM.dd e 'at' HH:mm:ss zzz" ->>
410 * 1996.07.10 AD at 15:08:56 PDT
411 *
412 * @param cal Calendar set to the date and time to be formatted
413 * into a date/time string.
414 * @param appendTo Output parameter to receive result.
415 * Result is appended to existing contents.
416 * @param posIter On return, can be used to iterate over positions
417 * of fields generated by this format call. Field values
418 * are defined in UDateFormatField.
419 * @param status Input/output param set to success/failure code.
420 * @return Reference to 'appendTo' parameter.
421 * @stable ICU 4.4
422 */
423 virtual UnicodeString& format( Calendar& cal,
424 UnicodeString& appendTo,
425 FieldPositionIterator* posIter,
426 UErrorCode& status) const;
427
428 /**
429 * Format a date or time, which is the standard millis since 24:00 GMT, Jan
430 * 1, 1970. Overrides DateFormat pure virtual method.
431 * <P>
432 * Example: using the US locale: "yyyy.MM.dd e 'at' HH:mm:ss zzz" ->>
433 * 1996.07.10 AD at 15:08:56 PDT
434 *
435 * @param obj A Formattable containing the date-time value to be formatted
436 * into a date-time string. If the type of the Formattable
437 * is a numeric type, it is treated as if it were an
438 * instance of Date.
439 * @param appendTo Output parameter to receive result.
440 * Result is appended to existing contents.
441 * @param pos The formatting position. On input: an alignment field,
442 * if desired. On output: the offsets of the alignment field.
443 * @param status Input/output param set to success/failure code.
444 * @return Reference to 'appendTo' parameter.
445 * @stable ICU 2.0
446 */
447 virtual UnicodeString& format( const Formattable& obj,
448 UnicodeString& appendTo,
449 FieldPosition& pos,
450 UErrorCode& status) const;
451
452 /**
453 * Format a date or time, which is the standard millis since 24:00 GMT, Jan
454 * 1, 1970. Overrides DateFormat pure virtual method.
455 * <P>
456 * Example: using the US locale: "yyyy.MM.dd e 'at' HH:mm:ss zzz" ->>
457 * 1996.07.10 AD at 15:08:56 PDT
458 *
459 * @param obj A Formattable containing the date-time value to be formatted
460 * into a date-time string. If the type of the Formattable
461 * is a numeric type, it is treated as if it were an
462 * instance of Date.
463 * @param appendTo Output parameter to receive result.
464 * Result is appended to existing contents.
465 * @param posIter On return, can be used to iterate over positions
466 * of fields generated by this format call. Field values
467 * are defined in UDateFormatField.
468 * @param status Input/output param set to success/failure code.
469 * @return Reference to 'appendTo' parameter.
470 * @stable ICU 4.4
471 */
472 virtual UnicodeString& format( const Formattable& obj,
473 UnicodeString& appendTo,
474 FieldPositionIterator* posIter,
475 UErrorCode& status) const;
476
477 /**
478 * Redeclared DateFormat method.
479 * @param date the Date value to be formatted.
480 * @param appendTo Output parameter to receive result.
481 * Result is appended to existing contents.
482 * @param fieldPosition The formatting position. On input: an alignment field,
483 * if desired. On output: the offsets of the alignment field.
484 * @return Reference to 'appendTo' parameter.
485 * @stable ICU 2.1
486 */
487 UnicodeString& format(UDate date,
488 UnicodeString& appendTo,
489 FieldPosition& fieldPosition) const;
490
491 /**
492 * Redeclared DateFormat method.
493 * @param date the Date value to be formatted.
494 * @param appendTo Output parameter to receive result.
495 * Result is appended to existing contents.
496 * @param posIter On return, can be used to iterate over positions
497 * of fields generated by this format call. Field values
498 * are defined in UDateFormatField.
499 * @param status Input/output param set to success/failure code.
500 * @return Reference to 'appendTo' parameter.
501 * @stable ICU 4.4
502 */
503 UnicodeString& format(UDate date,
504 UnicodeString& appendTo,
505 FieldPositionIterator* posIter,
506 UErrorCode& status) const;
507
508 /**
509 * Redeclared DateFormat method.
510 * @param obj Object to be formatted.
511 * @param appendTo Output parameter to receive result.
512 * Result is appended to existing contents.
513 * @param status Input/output success/failure code.
514 * @return Reference to 'appendTo' parameter.
515 * @stable ICU 2.0
516 */
517 UnicodeString& format(const Formattable& obj,
518 UnicodeString& appendTo,
519 UErrorCode& status) const;
520
521 /**
522 * Redeclared DateFormat method.
523 * @param date Date value to be formatted.
524 * @param appendTo Output parameter to receive result.
525 * Result is appended to existing contents.
526 * @return Reference to 'appendTo' parameter.
527 * @stable ICU 2.0
528 */
529 UnicodeString& format(UDate date, UnicodeString& appendTo) const;
530
531 /**
532 * Parse a date/time string beginning at the given parse position. For
533 * example, a time text "07/10/96 4:5 PM, PDT" will be parsed into a Date
534 * that is equivalent to Date(837039928046).
535 * <P>
536 * By default, parsing is lenient: If the input is not in the form used by
537 * this object's format method but can still be parsed as a date, then the
538 * parse succeeds. Clients may insist on strict adherence to the format by
539 * calling setLenient(false).
540 * @see DateFormat::setLenient(boolean)
541 *
542 * @param text The date/time string to be parsed
543 * @param cal A Calendar set on input to the date and time to be used for
544 * missing values in the date/time string being parsed, and set
545 * on output to the parsed date/time. When the calendar type is
546 * different from the internal calendar held by this SimpleDateFormat
547 * instance, the internal calendar will be cloned to a work
548 * calendar set to the same milliseconds and time zone as the
549 * cal parameter, field values will be parsed based on the work
550 * calendar, then the result (milliseconds and time zone) will
551 * be set in this calendar.
552 * @param pos On input, the position at which to start parsing; on
553 * output, the position at which parsing terminated, or the
554 * start position if the parse failed.
555 * @stable ICU 2.1
556 */
557 virtual void parse( const UnicodeString& text,
558 Calendar& cal,
559 ParsePosition& pos) const;
560
561 /**
562 * Parse a date/time string starting at the given parse position. For
563 * example, a time text "07/10/96 4:5 PM, PDT" will be parsed into a Date
564 * that is equivalent to Date(837039928046).
565 * <P>
566 * By default, parsing is lenient: If the input is not in the form used by
567 * this object's format method but can still be parsed as a date, then the
568 * parse succeeds. Clients may insist on strict adherence to the format by
569 * calling setLenient(false).
570 * @see DateFormat::setLenient(boolean)
571 * <P>
572 * Note that the normal date formats associated with some calendars - such
573 * as the Chinese lunar calendar - do not specify enough fields to enable
574 * dates to be parsed unambiguously. In the case of the Chinese lunar
575 * calendar, while the year within the current 60-year cycle is specified,
576 * the number of such cycles since the start date of the calendar (in the
577 * ERA field of the Calendar object) is not normally part of the format,
578 * and parsing may assume the wrong era. For cases such as this it is
579 * recommended that clients parse using the method
580 * parse(const UnicodeString&, Calendar& cal, ParsePosition&)
581 * with the Calendar passed in set to the current date, or to a date
582 * within the era/cycle that should be assumed if absent in the format.
583 *
584 * @param text The date/time string to be parsed
585 * @param pos On input, the position at which to start parsing; on
586 * output, the position at which parsing terminated, or the
587 * start position if the parse failed.
588 * @return A valid UDate if the input could be parsed.
589 * @stable ICU 2.0
590 */
591 UDate parse( const UnicodeString& text,
592 ParsePosition& pos) const;
593
594
595 /**
596 * Parse a date/time string. For example, a time text "07/10/96 4:5 PM, PDT"
597 * will be parsed into a UDate that is equivalent to Date(837039928046).
598 * Parsing begins at the beginning of the string and proceeds as far as
599 * possible. Assuming no parse errors were encountered, this function
600 * doesn't return any information about how much of the string was consumed
601 * by the parsing. If you need that information, use the version of
602 * parse() that takes a ParsePosition.
603 * <P>
604 * By default, parsing is lenient: If the input is not in the form used by
605 * this object's format method but can still be parsed as a date, then the
606 * parse succeeds. Clients may insist on strict adherence to the format by
607 * calling setLenient(false).
608 * @see DateFormat::setLenient(boolean)
609 * <P>
610 * Note that the normal date formats associated with some calendars - such
611 * as the Chinese lunar calendar - do not specify enough fields to enable
612 * dates to be parsed unambiguously. In the case of the Chinese lunar
613 * calendar, while the year within the current 60-year cycle is specified,
614 * the number of such cycles since the start date of the calendar (in the
615 * ERA field of the Calendar object) is not normally part of the format,
616 * and parsing may assume the wrong era. For cases such as this it is
617 * recommended that clients parse using the method
618 * parse(const UnicodeString&, Calendar& cal, ParsePosition&)
619 * with the Calendar passed in set to the current date, or to a date
620 * within the era/cycle that should be assumed if absent in the format.
621 *
622 * @param text The date/time string to be parsed into a UDate value.
623 * @param status Filled in with U_ZERO_ERROR if the parse was successful, and with
624 * an error value if there was a parse error.
625 * @return A valid UDate if the input could be parsed.
626 * @stable ICU 2.0
627 */
628 virtual UDate parse( const UnicodeString& text,
629 UErrorCode& status) const;
630
631 /**
632 * Set the start UDate used to interpret two-digit year strings.
633 * When dates are parsed having 2-digit year strings, they are placed within
634 * a assumed range of 100 years starting on the two digit start date. For
635 * example, the string "24-Jan-17" may be in the year 1817, 1917, 2017, or
636 * some other year. SimpleDateFormat chooses a year so that the resultant
637 * date is on or after the two digit start date and within 100 years of the
638 * two digit start date.
639 * <P>
640 * By default, the two digit start date is set to 80 years before the current
641 * time at which a SimpleDateFormat object is created.
642 * @param d start UDate used to interpret two-digit year strings.
643 * @param status Filled in with U_ZERO_ERROR if the parse was successful, and with
644 * an error value if there was a parse error.
645 * @stable ICU 2.0
646 */
647 virtual void set2DigitYearStart(UDate d, UErrorCode& status);
648
649 /**
650 * Get the start UDate used to interpret two-digit year strings.
651 * When dates are parsed having 2-digit year strings, they are placed within
652 * a assumed range of 100 years starting on the two digit start date. For
653 * example, the string "24-Jan-17" may be in the year 1817, 1917, 2017, or
654 * some other year. SimpleDateFormat chooses a year so that the resultant
655 * date is on or after the two digit start date and within 100 years of the
656 * two digit start date.
657 * <P>
658 * By default, the two digit start date is set to 80 years before the current
659 * time at which a SimpleDateFormat object is created.
660 * @param status Filled in with U_ZERO_ERROR if the parse was successful, and with
661 * an error value if there was a parse error.
662 * @stable ICU 2.0
663 */
664 UDate get2DigitYearStart(UErrorCode& status) const;
665
666 /**
667 * Return a pattern string describing this date format.
668 * @param result Output param to receive the pattern.
669 * @return A reference to 'result'.
670 * @stable ICU 2.0
671 */
672 virtual UnicodeString& toPattern(UnicodeString& result) const;
673
674 /**
675 * Return a localized pattern string describing this date format.
676 * In most cases, this will return the same thing as toPattern(),
677 * but a locale can specify characters to use in pattern descriptions
678 * in place of the ones described in this class's class documentation.
679 * (Presumably, letters that would be more mnemonic in that locale's
680 * language.) This function would produce a pattern using those
681 * letters.
682 *
683 * @param result Receives the localized pattern.
684 * @param status Output param set to success/failure code on
685 * exit. If the pattern is invalid, this will be
686 * set to a failure result.
687 * @return A reference to 'result'.
688 * @stable ICU 2.0
689 */
690 virtual UnicodeString& toLocalizedPattern(UnicodeString& result,
691 UErrorCode& status) const;
692
693 /**
694 * Apply the given unlocalized pattern string to this date format.
695 * (i.e., after this call, this formatter will format dates according to
696 * the new pattern)
697 *
698 * @param pattern The pattern to be applied.
699 * @stable ICU 2.0
700 */
701 virtual void applyPattern(const UnicodeString& pattern);
702
703 /**
704 * Apply the given localized pattern string to this date format.
705 * (see toLocalizedPattern() for more information on localized patterns.)
706 *
707 * @param pattern The localized pattern to be applied.
708 * @param status Output param set to success/failure code on
709 * exit. If the pattern is invalid, this will be
710 * set to a failure result.
711 * @stable ICU 2.0
712 */
713 virtual void applyLocalizedPattern(const UnicodeString& pattern,
714 UErrorCode& status);
715
716 /**
717 * Gets the date/time formatting symbols (this is an object carrying
718 * the various strings and other symbols used in formatting: e.g., month
719 * names and abbreviations, time zone names, AM/PM strings, etc.)
720 * @return a copy of the date-time formatting data associated
721 * with this date-time formatter.
722 * @stable ICU 2.0
723 */
724 virtual const DateFormatSymbols* getDateFormatSymbols(void) const;
725
726 /**
727 * Set the date/time formatting symbols. The caller no longer owns the
728 * DateFormatSymbols object and should not delete it after making this call.
729 * @param newFormatSymbols the given date-time formatting symbols to copy.
730 * @stable ICU 2.0
731 */
732 virtual void adoptDateFormatSymbols(DateFormatSymbols* newFormatSymbols);
733
734 /**
735 * Set the date/time formatting data.
736 * @param newFormatSymbols the given date-time formatting symbols to copy.
737 * @stable ICU 2.0
738 */
739 virtual void setDateFormatSymbols(const DateFormatSymbols& newFormatSymbols);
740
741 /**
742 * Return the class ID for this class. This is useful only for comparing to
743 * a return value from getDynamicClassID(). For example:
744 * <pre>
745 * . Base* polymorphic_pointer = createPolymorphicObject();
746 * . if (polymorphic_pointer->getDynamicClassID() ==
747 * . erived::getStaticClassID()) ...
748 * </pre>
749 * @return The class ID for all objects of this class.
750 * @stable ICU 2.0
751 */
752 static UClassID U_EXPORT2 getStaticClassID(void);
753
754 /**
755 * Returns a unique class ID POLYMORPHICALLY. Pure virtual override. This
756 * method is to implement a simple version of RTTI, since not all C++
757 * compilers support genuine RTTI. Polymorphic operator==() and clone()
758 * methods call this method.
759 *
760 * @return The class ID for this object. All objects of a
761 * given class have the same class ID. Objects of
762 * other classes have different class IDs.
763 * @stable ICU 2.0
764 */
765 virtual UClassID getDynamicClassID(void) const;
766
767 /**
768 * Set the calendar to be used by this date format. Initially, the default
769 * calendar for the specified or default locale is used. The caller should
770 * not delete the Calendar object after it is adopted by this call.
771 * Adopting a new calendar will change to the default symbols.
772 *
773 * @param calendarToAdopt Calendar object to be adopted.
774 * @stable ICU 2.0
775 */
776 virtual void adoptCalendar(Calendar* calendarToAdopt);
777
778 /* Cannot use #ifndef U_HIDE_INTERNAL_API for the following draft method since it is virtual */
779 /**
780 * Set a particular UDisplayContext value in the formatter, such as
781 * UDISPCTX_CAPITALIZATION_FOR_STANDALONE.
782 * @param value The UDisplayContext value to set.
783 * @param status Input/output status. If at entry this indicates a failure
784 * status, the function will do nothing; otherwise this will be
785 * updated with any new status from the function.
786 * @internal ICU 50 technology preview
787 */
788 virtual void setContext(UDisplayContext value, UErrorCode& status);
789
790 /* Cannot use #ifndef U_HIDE_INTERNAL_API for the following draft method since it is virtual */
791 /**
792 * Get the formatter's UDisplayContext value for the specified UDisplayContextType,
793 * such as UDISPCTX_TYPE_CAPITALIZATION.
794 * @param type The UDisplayContextType whose value to return
795 * @param status Input/output status. If at entry this indicates a failure
796 * status, the function will do nothing; otherwise this will be
797 * updated with any new status from the function.
798 * @return The UDisplayContextValue for the specified type.
799 * @internal ICU 50 technology preview
800 */
801 virtual UDisplayContext getContext(UDisplayContextType type, UErrorCode& status) const;
802
803 /* Cannot use #ifndef U_HIDE_INTERNAL_API for the following methods since they are virtual */
804 /**
805 * Sets the TimeZoneFormat to be used by this date/time formatter.
806 * The caller should not delete the TimeZoneFormat object after
807 * it is adopted by this call.
808 * @param timeZoneFormatToAdopt The TimeZoneFormat object to be adopted.
809 * @internal ICU 49 technology preview
810 */
811 virtual void adoptTimeZoneFormat(TimeZoneFormat* timeZoneFormatToAdopt);
812
813 /**
814 * Sets the TimeZoneFormat to be used by this date/time formatter.
815 * @param newTimeZoneFormat The TimeZoneFormat object to copy.
816 * @internal ICU 49 technology preview
817 */
818 virtual void setTimeZoneFormat(const TimeZoneFormat& newTimeZoneFormat);
819
820 /**
821 * Gets the time zone format object associated with this date/time formatter.
822 * @return the time zone format associated with this date/time formatter.
823 * @internal ICU 49 technology preview
824 */
825 virtual const TimeZoneFormat* getTimeZoneFormat(void) const;
826
827 #ifndef U_HIDE_INTERNAL_API
828 /**
829 * This is for ICU internal use only. Please do not use.
830 * Check whether the 'field' is smaller than all the fields covered in
831 * pattern, return TRUE if it is. The sequence of calendar field,
832 * from large to small is: ERA, YEAR, MONTH, DATE, AM_PM, HOUR, MINUTE,...
833 * @param field the calendar field need to check against
834 * @return TRUE if the 'field' is smaller than all the fields
835 * covered in pattern. FALSE otherwise.
836 * @internal ICU 4.0
837 */
838 UBool isFieldUnitIgnored(UCalendarDateFields field) const;
839
840
841 /**
842 * This is for ICU internal use only. Please do not use.
843 * Check whether the 'field' is smaller than all the fields covered in
844 * pattern, return TRUE if it is. The sequence of calendar field,
845 * from large to small is: ERA, YEAR, MONTH, DATE, AM_PM, HOUR, MINUTE,...
846 * @param pattern the pattern to check against
847 * @param field the calendar field need to check against
848 * @return TRUE if the 'field' is smaller than all the fields
849 * covered in pattern. FALSE otherwise.
850 * @internal ICU 4.0
851 */
852 static UBool isFieldUnitIgnored(const UnicodeString& pattern,
853 UCalendarDateFields field);
854
855 /**
856 * This is for ICU internal use only. Please do not use.
857 * Get the locale of this simple date formatter.
858 * It is used in DateIntervalFormat.
859 *
860 * @return locale in this simple date formatter
861 * @internal ICU 4.0
862 */
863 const Locale& getSmpFmtLocale(void) const;
864 #endif /* U_HIDE_INTERNAL_API */
865
866 private:
867 friend class DateFormat;
868
869 void initializeDefaultCentury(void);
870
871 SimpleDateFormat(); // default constructor not implemented
872
873 /**
874 * Used by the DateFormat factory methods to construct a SimpleDateFormat.
875 * @param timeStyle the time style.
876 * @param dateStyle the date style.
877 * @param locale the given locale.
878 * @param status Output param set to success/failure code on
879 * exit.
880 */
881 SimpleDateFormat(EStyle timeStyle, EStyle dateStyle, const Locale& locale, UErrorCode& status);
882
883 /**
884 * Construct a SimpleDateFormat for the given locale. If no resource data
885 * is available, create an object of last resort, using hard-coded strings.
886 * This is an internal method, called by DateFormat. It should never fail.
887 * @param locale the given locale.
888 * @param status Output param set to success/failure code on
889 * exit.
890 */
891 SimpleDateFormat(const Locale& locale, UErrorCode& status); // Use default pattern
892
893 /**
894 * Hook called by format(... FieldPosition& ...) and format(...FieldPositionIterator&...)
895 */
896 UnicodeString& _format(Calendar& cal, UnicodeString& appendTo, FieldPositionHandler& handler, UErrorCode& status) const;
897
898 /**
899 * Called by format() to format a single field.
900 *
901 * @param appendTo Output parameter to receive result.
902 * Result is appended to existing contents.
903 * @param ch The format character we encountered in the pattern.
904 * @param count Number of characters in the current pattern symbol (e.g.,
905 * "yyyy" in the pattern would result in a call to this function
906 * with ch equal to 'y' and count equal to 4)
907 * @param capitalizationContext Capitalization context for this date format.
908 * @param fieldNum Zero-based numbering of current field within the overall format.
909 * @param handler Records information about field positions.
910 * @param cal Calendar to use
911 * @param status Receives a status code, which will be U_ZERO_ERROR if the operation
912 * succeeds.
913 */
914 void subFormat(UnicodeString &appendTo,
915 UChar ch,
916 int32_t count,
917 UDisplayContext capitalizationContext,
918 int32_t fieldNum,
919 FieldPositionHandler& handler,
920 Calendar& cal,
921 UErrorCode& status) const; // in case of illegal argument
922
923 /**
924 * Used by subFormat() to format a numeric value.
925 * Appends to toAppendTo a string representation of "value"
926 * having a number of digits between "minDigits" and
927 * "maxDigits". Uses the DateFormat's NumberFormat.
928 *
929 * @param currentNumberFormat
930 * @param appendTo Output parameter to receive result.
931 * Formatted number is appended to existing contents.
932 * @param value Value to format.
933 * @param minDigits Minimum number of digits the result should have
934 * @param maxDigits Maximum number of digits the result should have
935 */
936 void zeroPaddingNumber(NumberFormat *currentNumberFormat,
937 UnicodeString &appendTo,
938 int32_t value,
939 int32_t minDigits,
940 int32_t maxDigits) const;
941
942 /**
943 * Return true if the given format character, occuring count
944 * times, represents a numeric field.
945 */
946 static UBool isNumeric(UChar formatChar, int32_t count);
947
948 /**
949 * Returns TRUE if the patternOffset is at the start of a numeric field.
950 */
951 static UBool isAtNumericField(const UnicodeString &pattern, int32_t patternOffset);
952
953 /**
954 * Returns TRUE if the patternOffset is right after a non-numeric field.
955 */
956 static UBool isAfterNonNumericField(const UnicodeString &pattern, int32_t patternOffset);
957
958 /**
959 * initializes fCalendar from parameters. Returns fCalendar as a convenience.
960 * @param adoptZone Zone to be adopted, or NULL for TimeZone::createDefault().
961 * @param locale Locale of the calendar
962 * @param status Error code
963 * @return the newly constructed fCalendar
964 */
965 Calendar *initializeCalendar(TimeZone* adoptZone, const Locale& locale, UErrorCode& status);
966
967 /**
968 * initializes fSymbols from parameters.
969 * @param locale Locale of the symbols
970 * @param calendar Alias to Calendar that will be used.
971 * @param status Error code
972 */
973 void initializeSymbols(const Locale& locale, Calendar* calendar, UErrorCode& status);
974
975 /**
976 * Called by several of the constructors to load pattern data and formatting symbols
977 * out of a resource bundle and initialize the locale based on it.
978 * @param timeStyle The time style, as passed to DateFormat::createDateInstance().
979 * @param dateStyle The date style, as passed to DateFormat::createTimeInstance().
980 * @param locale The locale to load the patterns from.
981 * @param status Filled in with an error code if loading the data from the
982 * resources fails.
983 */
984 void construct(EStyle timeStyle, EStyle dateStyle, const Locale& locale, UErrorCode& status);
985
986 /**
987 * Called by construct() and the various constructors to set up the SimpleDateFormat's
988 * Calendar and NumberFormat objects.
989 * @param locale The locale for which we want a Calendar and a NumberFormat.
990 * @param status Filled in with an error code if creating either subobject fails.
991 */
992 void initialize(const Locale& locale, UErrorCode& status);
993
994 /**
995 * Private code-size reduction function used by subParse.
996 * @param text the time text being parsed.
997 * @param start where to start parsing.
998 * @param field the date field being parsed.
999 * @param stringArray the string array to parsed.
1000 * @param stringArrayCount the size of the array.
1001 * @param monthPattern pointer to leap month pattern, or NULL if none.
1002 * @param cal a Calendar set to the date and time to be formatted
1003 * into a date/time string.
1004 * @return the new start position if matching succeeded; a negative number
1005 * indicating matching failure, otherwise.
1006 */
1007 int32_t matchString(const UnicodeString& text, int32_t start, UCalendarDateFields field,
1008 const UnicodeString* stringArray, int32_t stringArrayCount,
1009 const UnicodeString* monthPattern, Calendar& cal) const;
1010
1011 /**
1012 * Private code-size reduction function used by subParse.
1013 * @param text the time text being parsed.
1014 * @param start where to start parsing.
1015 * @param field the date field being parsed.
1016 * @param stringArray the string array to parsed.
1017 * @param stringArrayCount the size of the array.
1018 * @param cal a Calendar set to the date and time to be formatted
1019 * into a date/time string.
1020 * @return the new start position if matching succeeded; a negative number
1021 * indicating matching failure, otherwise.
1022 */
1023 int32_t matchQuarterString(const UnicodeString& text, int32_t start, UCalendarDateFields field,
1024 const UnicodeString* stringArray, int32_t stringArrayCount, Calendar& cal) const;
1025
1026 /**
1027 * Private function used by subParse to match literal pattern text.
1028 *
1029 * @param pattern the pattern string
1030 * @param patternOffset the starting offset into the pattern text. On
1031 * outupt will be set the offset of the first non-literal character in the pattern
1032 * @param text the text being parsed
1033 * @param textOffset the starting offset into the text. On output
1034 * will be set to the offset of the character after the match
1035 * @param lenient <code>TRUE</code> if the parse is lenient, <code>FALSE</code> otherwise.
1036 *
1037 * @return <code>TRUE</code> if the literal text could be matched, <code>FALSE</code> otherwise.
1038 */
1039 static UBool matchLiterals(const UnicodeString &pattern, int32_t &patternOffset,
1040 const UnicodeString &text, int32_t &textOffset, UBool lenient);
1041
1042 /**
1043 * Private member function that converts the parsed date strings into
1044 * timeFields. Returns -start (for ParsePosition) if failed.
1045 * @param text the time text to be parsed.
1046 * @param start where to start parsing.
1047 * @param ch the pattern character for the date field text to be parsed.
1048 * @param count the count of a pattern character.
1049 * @param obeyCount if true then the count is strictly obeyed.
1050 * @param allowNegative
1051 * @param ambiguousYear If true then the two-digit year == the default start year.
1052 * @param saveHebrewMonth Used to hang onto month until year is known.
1053 * @param cal a Calendar set to the date and time to be formatted
1054 * into a date/time string.
1055 * @param patLoc
1056 * @param numericLeapMonthFormatter If non-null, used to parse numeric leap months.
1057 * @return the new start position if matching succeeded; a negative number
1058 * indicating matching failure, otherwise.
1059 */
1060 int32_t subParse(const UnicodeString& text, int32_t& start, UChar ch, int32_t count,
1061 UBool obeyCount, UBool allowNegative, UBool ambiguousYear[], int32_t& saveHebrewMonth, Calendar& cal,
1062 int32_t patLoc, MessageFormat * numericLeapMonthFormatter) const;
1063
1064 void parseInt(const UnicodeString& text,
1065 Formattable& number,
1066 ParsePosition& pos,
1067 UBool allowNegative,
1068 NumberFormat *fmt) const;
1069
1070 void parseInt(const UnicodeString& text,
1071 Formattable& number,
1072 int32_t maxDigits,
1073 ParsePosition& pos,
1074 UBool allowNegative,
1075 NumberFormat *fmt) const;
1076
1077 int32_t checkIntSuffix(const UnicodeString& text, int32_t start,
1078 int32_t patLoc, UBool isNegative) const;
1079
1080 /**
1081 * Translate a pattern, mapping each character in the from string to the
1082 * corresponding character in the to string. Return an error if the original
1083 * pattern contains an unmapped character, or if a quote is unmatched.
1084 * Quoted (single quotes only) material is not translated.
1085 * @param originalPattern the original pattern.
1086 * @param translatedPattern Output param to receive the translited pattern.
1087 * @param from the characters to be translited from.
1088 * @param to the characters to be translited to.
1089 * @param status Receives a status code, which will be U_ZERO_ERROR
1090 * if the operation succeeds.
1091 */
1092 static void translatePattern(const UnicodeString& originalPattern,
1093 UnicodeString& translatedPattern,
1094 const UnicodeString& from,
1095 const UnicodeString& to,
1096 UErrorCode& status);
1097
1098 /**
1099 * Sets the starting date of the 100-year window that dates with 2-digit years
1100 * are considered to fall within.
1101 * @param startDate the start date
1102 * @param status Receives a status code, which will be U_ZERO_ERROR
1103 * if the operation succeeds.
1104 */
1105 void parseAmbiguousDatesAsAfter(UDate startDate, UErrorCode& status);
1106
1107 /**
1108 * Return the length matched by the given affix, or -1 if none.
1109 * Runs of white space in the affix, match runs of white space in
1110 * the input.
1111 * @param affix pattern string, taken as a literal
1112 * @param input input text
1113 * @param pos offset into input at which to begin matching
1114 * @return length of input that matches, or -1 if match failure
1115 */
1116 int32_t compareSimpleAffix(const UnicodeString& affix,
1117 const UnicodeString& input,
1118 int32_t pos) const;
1119
1120 /**
1121 * Skip over a run of zero or more Pattern_White_Space characters at
1122 * pos in text.
1123 */
1124 int32_t skipPatternWhiteSpace(const UnicodeString& text, int32_t pos) const;
1125
1126 /**
1127 * Skip over a run of zero or more isUWhiteSpace() characters at pos
1128 * in text.
1129 */
1130 int32_t skipUWhiteSpace(const UnicodeString& text, int32_t pos) const;
1131
1132 /**
1133 * Initialize NumberFormat instances used for numbering system overrides.
1134 */
1135 void initNumberFormatters(const Locale &locale,UErrorCode &status);
1136
1137 /**
1138 * Get the numbering system to be used for a particular field.
1139 */
1140 NumberFormat * getNumberFormatByIndex(UDateFormatField index) const;
1141
1142 /**
1143 * Parse the given override string and set up structures for number formats
1144 */
1145 void processOverrideString(const Locale &locale, const UnicodeString &str, int8_t type, UErrorCode &status);
1146
1147 /**
1148 * Used to map pattern characters to Calendar field identifiers.
1149 */
1150 static const UCalendarDateFields fgPatternIndexToCalendarField[];
1151
1152 /**
1153 * Map index into pattern character string to DateFormat field number
1154 */
1155 static const UDateFormatField fgPatternIndexToDateFormatField[];
1156
1157 /**
1158 * Lazy TimeZoneFormat instantiation, semantically const
1159 */
1160 TimeZoneFormat *tzFormat() const;
1161
1162 /**
1163 * Used to map Calendar field to field level.
1164 * The larger the level, the smaller the field unit.
1165 * For example, UCAL_ERA level is 0, UCAL_YEAR level is 10,
1166 * UCAL_MONTH level is 20.
1167 */
1168 static const int32_t fgCalendarFieldToLevel[];
1169 static const int32_t fgPatternCharToLevel[];
1170
1171 /**
1172 * The formatting pattern for this formatter.
1173 */
1174 UnicodeString fPattern;
1175
1176 /**
1177 * The numbering system override for dates.
1178 */
1179 UnicodeString fDateOverride;
1180
1181 /**
1182 * The numbering system override for times.
1183 */
1184 UnicodeString fTimeOverride;
1185
1186
1187 /**
1188 * The original locale used (for reloading symbols)
1189 */
1190 Locale fLocale;
1191
1192 /**
1193 * A pointer to an object containing the strings to use in formatting (e.g.,
1194 * month and day names, AM and PM strings, time zone names, etc.)
1195 */
1196 DateFormatSymbols* fSymbols; // Owned
1197
1198 /**
1199 * The time zone formatter
1200 */
1201 TimeZoneFormat* fTimeZoneFormat;
1202
1203 /**
1204 * If dates have ambiguous years, we map them into the century starting
1205 * at defaultCenturyStart, which may be any date. If defaultCenturyStart is
1206 * set to SYSTEM_DEFAULT_CENTURY, which it is by default, then the system
1207 * values are used. The instance values defaultCenturyStart and
1208 * defaultCenturyStartYear are only used if explicitly set by the user
1209 * through the API method parseAmbiguousDatesAsAfter().
1210 */
1211 UDate fDefaultCenturyStart;
1212
1213 /**
1214 * See documentation for defaultCenturyStart.
1215 */
1216 /*transient*/ int32_t fDefaultCenturyStartYear;
1217
1218 int32_t tztype; // here to avoid api change
1219
1220 typedef struct NSOverride {
1221 NumberFormat *nf;
1222 int32_t hash;
1223 NSOverride *next;
1224 } NSOverride;
1225
1226 NumberFormat **fNumberFormatters;
1227
1228 NSOverride *fOverrideList;
1229
1230 UBool fHaveDefaultCentury;
1231
1232 UDisplayContext fCapitalizationContext;
1233 };
1234
1235 inline UDate
get2DigitYearStart(UErrorCode &)1236 SimpleDateFormat::get2DigitYearStart(UErrorCode& /*status*/) const
1237 {
1238 return fDefaultCenturyStart;
1239 }
1240
1241 inline UnicodeString&
format(const Formattable & obj,UnicodeString & appendTo,UErrorCode & status)1242 SimpleDateFormat::format(const Formattable& obj,
1243 UnicodeString& appendTo,
1244 UErrorCode& status) const {
1245 // Don't use Format:: - use immediate base class only,
1246 // in case immediate base modifies behavior later.
1247 return DateFormat::format(obj, appendTo, status);
1248 }
1249
1250 inline UnicodeString&
format(const Formattable & obj,UnicodeString & appendTo,FieldPosition & pos,UErrorCode & status)1251 SimpleDateFormat::format(const Formattable& obj,
1252 UnicodeString& appendTo,
1253 FieldPosition& pos,
1254 UErrorCode& status) const
1255 {
1256 // Don't use Format:: - use immediate base class only,
1257 // in case immediate base modifies behavior later.
1258 return DateFormat::format(obj, appendTo, pos, status);
1259 }
1260
1261 inline UnicodeString&
format(const Formattable & obj,UnicodeString & appendTo,FieldPositionIterator * posIter,UErrorCode & status)1262 SimpleDateFormat::format(const Formattable& obj,
1263 UnicodeString& appendTo,
1264 FieldPositionIterator* posIter,
1265 UErrorCode& status) const
1266 {
1267 // Don't use Format:: - use immediate base class only,
1268 // in case immediate base modifies behavior later.
1269 return DateFormat::format(obj, appendTo, posIter, status);
1270 }
1271
1272 inline UnicodeString&
format(UDate date,UnicodeString & appendTo,FieldPosition & fieldPosition)1273 SimpleDateFormat::format(UDate date,
1274 UnicodeString& appendTo,
1275 FieldPosition& fieldPosition) const {
1276 // Don't use Format:: - use immediate base class only,
1277 // in case immediate base modifies behavior later.
1278 return DateFormat::format(date, appendTo, fieldPosition);
1279 }
1280
1281 inline UnicodeString&
format(UDate date,UnicodeString & appendTo,FieldPositionIterator * posIter,UErrorCode & status)1282 SimpleDateFormat::format(UDate date,
1283 UnicodeString& appendTo,
1284 FieldPositionIterator* posIter,
1285 UErrorCode& status) const {
1286 // Don't use Format:: - use immediate base class only,
1287 // in case immediate base modifies behavior later.
1288 return DateFormat::format(date, appendTo, posIter, status);
1289 }
1290
1291 inline UnicodeString&
format(UDate date,UnicodeString & appendTo)1292 SimpleDateFormat::format(UDate date, UnicodeString& appendTo) const {
1293 return DateFormat::format(date, appendTo);
1294 }
1295
1296 U_NAMESPACE_END
1297
1298 #endif /* #if !UCONFIG_NO_FORMATTING */
1299
1300 #endif // _SMPDTFMT
1301 //eof
1302