1/* 2******************************************************************************** 3* Copyright (C) 1997-2015, International Business Machines 4* Corporation and others. All Rights Reserved. 5******************************************************************************** 6* 7* File DTFMTSYM.H 8* 9* Modification History: 10* 11* Date Name Description 12* 02/19/97 aliu Converted from java. 13* 07/21/98 stephen Added getZoneIndex() 14* Changed to match C++ conventions 15******************************************************************************** 16*/ 17 18#ifndef DTFMTSYM_H 19#define DTFMTSYM_H 20 21#include "unicode/utypes.h" 22 23#if !UCONFIG_NO_FORMATTING 24 25#include "unicode/calendar.h" 26#include "unicode/uobject.h" 27#include "unicode/locid.h" 28#include "unicode/udat.h" 29#include "unicode/ures.h" 30 31/** 32 * \file 33 * \brief C++ API: Symbols for formatting dates. 34 */ 35 36U_NAMESPACE_BEGIN 37 38/* forward declaration */ 39class SimpleDateFormat; 40class Hashtable; 41 42/** 43 * DateFormatSymbols is a public class for encapsulating localizable date-time 44 * formatting data -- including timezone data. DateFormatSymbols is used by 45 * DateFormat and SimpleDateFormat. 46 * <P> 47 * Rather than first creating a DateFormatSymbols to get a date-time formatter 48 * by using a SimpleDateFormat constructor, clients are encouraged to create a 49 * date-time formatter using the getTimeInstance(), getDateInstance(), or 50 * getDateTimeInstance() method in DateFormat. Each of these methods can return a 51 * date/time formatter initialized with a default format pattern along with the 52 * date-time formatting data for a given or default locale. After a formatter is 53 * created, clients may modify the format pattern using the setPattern function 54 * as so desired. For more information on using these formatter factory 55 * functions, see DateFormat. 56 * <P> 57 * If clients decide to create a date-time formatter with a particular format 58 * pattern and locale, they can do so with new SimpleDateFormat(aPattern, 59 * new DateFormatSymbols(aLocale)). This will load the appropriate date-time 60 * formatting data from the locale. 61 * <P> 62 * DateFormatSymbols objects are clonable. When clients obtain a 63 * DateFormatSymbols object, they can feel free to modify the date-time 64 * formatting data as necessary. For instance, clients can 65 * replace the localized date-time format pattern characters with the ones that 66 * they feel easy to remember. Or they can change the representative cities 67 * originally picked by default to using their favorite ones. 68 * <P> 69 * DateFormatSymbols are not expected to be subclassed. Data for a calendar is 70 * loaded out of resource bundles. The 'type' parameter indicates the type of 71 * calendar, for example, "gregorian" or "japanese". If the type is not gregorian 72 * (or NULL, or an empty string) then the type is appended to the resource name, 73 * for example, 'Eras_japanese' instead of 'Eras'. If the resource 'Eras_japanese' did 74 * not exist (even in root), then this class will fall back to just 'Eras', that is, 75 * Gregorian data. Therefore, the calendar implementor MUST ensure that the root 76 * locale at least contains any resources that are to be particularized for the 77 * calendar type. 78 */ 79class U_I18N_API DateFormatSymbols U_FINAL : public UObject { 80public: 81 /** 82 * Construct a DateFormatSymbols object by loading format data from 83 * resources for the default locale, in the default calendar (Gregorian). 84 * <P> 85 * NOTE: This constructor will never fail; if it cannot get resource 86 * data for the default locale, it will return a last-resort object 87 * based on hard-coded strings. 88 * 89 * @param status Status code. Failure 90 * results if the resources for the default cannot be 91 * found or cannot be loaded 92 * @stable ICU 2.0 93 */ 94 DateFormatSymbols(UErrorCode& status); 95 96 /** 97 * Construct a DateFormatSymbols object by loading format data from 98 * resources for the given locale, in the default calendar (Gregorian). 99 * 100 * @param locale Locale to load format data from. 101 * @param status Status code. Failure 102 * results if the resources for the locale cannot be 103 * found or cannot be loaded 104 * @stable ICU 2.0 105 */ 106 DateFormatSymbols(const Locale& locale, 107 UErrorCode& status); 108 109#ifndef U_HIDE_INTERNAL_API 110 /** 111 * Construct a DateFormatSymbols object by loading format data from 112 * resources for the default locale, in the default calendar (Gregorian). 113 * <P> 114 * NOTE: This constructor will never fail; if it cannot get resource 115 * data for the default locale, it will return a last-resort object 116 * based on hard-coded strings. 117 * 118 * @param type Type of calendar (as returned by Calendar::getType). 119 * Will be used to access the correct set of strings. 120 * (NULL or empty string defaults to "gregorian".) 121 * @param status Status code. Failure 122 * results if the resources for the default cannot be 123 * found or cannot be loaded 124 * @internal 125 */ 126 DateFormatSymbols(const char *type, UErrorCode& status); 127 128 /** 129 * Construct a DateFormatSymbols object by loading format data from 130 * resources for the given locale, in the default calendar (Gregorian). 131 * 132 * @param locale Locale to load format data from. 133 * @param type Type of calendar (as returned by Calendar::getType). 134 * Will be used to access the correct set of strings. 135 * (NULL or empty string defaults to "gregorian".) 136 * @param status Status code. Failure 137 * results if the resources for the locale cannot be 138 * found or cannot be loaded 139 * @internal 140 */ 141 DateFormatSymbols(const Locale& locale, 142 const char *type, 143 UErrorCode& status); 144#endif /* U_HIDE_INTERNAL_API */ 145 146 /** 147 * Copy constructor. 148 * @stable ICU 2.0 149 */ 150 DateFormatSymbols(const DateFormatSymbols&); 151 152 /** 153 * Assignment operator. 154 * @stable ICU 2.0 155 */ 156 DateFormatSymbols& operator=(const DateFormatSymbols&); 157 158 /** 159 * Destructor. This is nonvirtual because this class is not designed to be 160 * subclassed. 161 * @stable ICU 2.0 162 */ 163 virtual ~DateFormatSymbols(); 164 165 /** 166 * Return true if another object is semantically equal to this one. 167 * 168 * @param other the DateFormatSymbols object to be compared with. 169 * @return true if other is semantically equal to this. 170 * @stable ICU 2.0 171 */ 172 UBool operator==(const DateFormatSymbols& other) const; 173 174 /** 175 * Return true if another object is semantically unequal to this one. 176 * 177 * @param other the DateFormatSymbols object to be compared with. 178 * @return true if other is semantically unequal to this. 179 * @stable ICU 2.0 180 */ 181 UBool operator!=(const DateFormatSymbols& other) const { return !operator==(other); } 182 183 /** 184 * Gets abbreviated era strings. For example: "AD" and "BC". 185 * 186 * @param count Filled in with length of the array. 187 * @return the era strings. 188 * @stable ICU 2.0 189 */ 190 const UnicodeString* getEras(int32_t& count) const; 191 192 /** 193 * Sets abbreviated era strings. For example: "AD" and "BC". 194 * @param eras Array of era strings (DateFormatSymbols retains ownership.) 195 * @param count Filled in with length of the array. 196 * @stable ICU 2.0 197 */ 198 void setEras(const UnicodeString* eras, int32_t count); 199 200 /** 201 * Gets era name strings. For example: "Anno Domini" and "Before Christ". 202 * 203 * @param count Filled in with length of the array. 204 * @return the era name strings. 205 * @stable ICU 3.4 206 */ 207 const UnicodeString* getEraNames(int32_t& count) const; 208 209 /** 210 * Sets era name strings. For example: "Anno Domini" and "Before Christ". 211 * @param eraNames Array of era name strings (DateFormatSymbols retains ownership.) 212 * @param count Filled in with length of the array. 213 * @stable ICU 3.6 214 */ 215 void setEraNames(const UnicodeString* eraNames, int32_t count); 216 217 /** 218 * Gets narrow era strings. For example: "A" and "B". 219 * 220 * @param count Filled in with length of the array. 221 * @return the narrow era strings. 222 * @stable ICU 4.2 223 */ 224 const UnicodeString* getNarrowEras(int32_t& count) const; 225 226 /** 227 * Sets narrow era strings. For example: "A" and "B". 228 * @param narrowEras Array of narrow era strings (DateFormatSymbols retains ownership.) 229 * @param count Filled in with length of the array. 230 * @stable ICU 4.2 231 */ 232 void setNarrowEras(const UnicodeString* narrowEras, int32_t count); 233 234 /** 235 * Gets month strings. For example: "January", "February", etc. 236 * @param count Filled in with length of the array. 237 * @return the month strings. (DateFormatSymbols retains ownership.) 238 * @stable ICU 2.0 239 */ 240 const UnicodeString* getMonths(int32_t& count) const; 241 242 /** 243 * Sets month strings. For example: "January", "February", etc. 244 * 245 * @param months the new month strings. (not adopted; caller retains ownership) 246 * @param count Filled in with length of the array. 247 * @stable ICU 2.0 248 */ 249 void setMonths(const UnicodeString* months, int32_t count); 250 251 /** 252 * Gets short month strings. For example: "Jan", "Feb", etc. 253 * 254 * @param count Filled in with length of the array. 255 * @return the short month strings. (DateFormatSymbols retains ownership.) 256 * @stable ICU 2.0 257 */ 258 const UnicodeString* getShortMonths(int32_t& count) const; 259 260 /** 261 * Sets short month strings. For example: "Jan", "Feb", etc. 262 * @param count Filled in with length of the array. 263 * @param shortMonths the new short month strings. (not adopted; caller retains ownership) 264 * @stable ICU 2.0 265 */ 266 void setShortMonths(const UnicodeString* shortMonths, int32_t count); 267 268 /** 269 * Selector for date formatting context 270 * @stable ICU 3.6 271 */ 272 enum DtContextType { 273 FORMAT, 274 STANDALONE, 275 DT_CONTEXT_COUNT 276 }; 277 278 /** 279 * Selector for date formatting width 280 * @stable ICU 3.6 281 */ 282 enum DtWidthType { 283 ABBREVIATED, 284 WIDE, 285 NARROW, 286 /** 287 * Short width is currently only supported for weekday names. 288 * @stable ICU 51 289 */ 290 SHORT, 291 /** 292 */ 293 DT_WIDTH_COUNT = 4 294 }; 295 296 /** 297 * Gets month strings by width and context. For example: "January", "February", etc. 298 * @param count Filled in with length of the array. 299 * @param context The formatting context, either FORMAT or STANDALONE 300 * @param width The width of returned strings, either WIDE, ABBREVIATED, or NARROW. 301 * @return the month strings. (DateFormatSymbols retains ownership.) 302 * @stable ICU 3.4 303 */ 304 const UnicodeString* getMonths(int32_t& count, DtContextType context, DtWidthType width) const; 305 306 /** 307 * Sets month strings by width and context. For example: "January", "February", etc. 308 * 309 * @param months The new month strings. (not adopted; caller retains ownership) 310 * @param count Filled in with length of the array. 311 * @param context The formatting context, either FORMAT or STANDALONE 312 * @param width The width of returned strings, either WIDE, ABBREVIATED, or NARROW. 313 * @stable ICU 3.6 314 */ 315 void setMonths(const UnicodeString* months, int32_t count, DtContextType context, DtWidthType width); 316 317 /** 318 * Gets wide weekday strings. For example: "Sunday", "Monday", etc. 319 * @param count Filled in with length of the array. 320 * @return the weekday strings. (DateFormatSymbols retains ownership.) 321 * @stable ICU 2.0 322 */ 323 const UnicodeString* getWeekdays(int32_t& count) const; 324 325 326 /** 327 * Sets wide weekday strings. For example: "Sunday", "Monday", etc. 328 * @param weekdays the new weekday strings. (not adopted; caller retains ownership) 329 * @param count Filled in with length of the array. 330 * @stable ICU 2.0 331 */ 332 void setWeekdays(const UnicodeString* weekdays, int32_t count); 333 334 /** 335 * Gets abbreviated weekday strings. For example: "Sun", "Mon", etc. (Note: The method name is 336 * misleading; it does not get the CLDR-style "short" weekday strings, e.g. "Su", "Mo", etc.) 337 * @param count Filled in with length of the array. 338 * @return the abbreviated weekday strings. (DateFormatSymbols retains ownership.) 339 * @stable ICU 2.0 340 */ 341 const UnicodeString* getShortWeekdays(int32_t& count) const; 342 343 /** 344 * Sets abbreviated weekday strings. For example: "Sun", "Mon", etc. (Note: The method name is 345 * misleading; it does not set the CLDR-style "short" weekday strings, e.g. "Su", "Mo", etc.) 346 * @param abbrevWeekdays the new abbreviated weekday strings. (not adopted; caller retains ownership) 347 * @param count Filled in with length of the array. 348 * @stable ICU 2.0 349 */ 350 void setShortWeekdays(const UnicodeString* abbrevWeekdays, int32_t count); 351 352 /** 353 * Gets weekday strings by width and context. For example: "Sunday", "Monday", etc. 354 * @param count Filled in with length of the array. 355 * @param context The formatting context, either FORMAT or STANDALONE 356 * @param width The width of returned strings, either WIDE, ABBREVIATED, SHORT, or NARROW 357 * @return the month strings. (DateFormatSymbols retains ownership.) 358 * @stable ICU 3.4 359 */ 360 const UnicodeString* getWeekdays(int32_t& count, DtContextType context, DtWidthType width) const; 361 362 /** 363 * Sets weekday strings by width and context. For example: "Sunday", "Monday", etc. 364 * @param weekdays The new weekday strings. (not adopted; caller retains ownership) 365 * @param count Filled in with length of the array. 366 * @param context The formatting context, either FORMAT or STANDALONE 367 * @param width The width of returned strings, either WIDE, ABBREVIATED, SHORT, or NARROW 368 * @stable ICU 3.6 369 */ 370 void setWeekdays(const UnicodeString* weekdays, int32_t count, DtContextType context, DtWidthType width); 371 372 /** 373 * Gets quarter strings by width and context. For example: "1st Quarter", "2nd Quarter", etc. 374 * @param count Filled in with length of the array. 375 * @param context The formatting context, either FORMAT or STANDALONE 376 * @param width The width of returned strings, either WIDE or ABBREVIATED. There 377 * are no NARROW quarters. 378 * @return the quarter strings. (DateFormatSymbols retains ownership.) 379 * @stable ICU 3.6 380 */ 381 const UnicodeString* getQuarters(int32_t& count, DtContextType context, DtWidthType width) const; 382 383 /** 384 * Sets quarter strings by width and context. For example: "1st Quarter", "2nd Quarter", etc. 385 * 386 * @param quarters The new quarter strings. (not adopted; caller retains ownership) 387 * @param count Filled in with length of the array. 388 * @param context The formatting context, either FORMAT or STANDALONE 389 * @param width The width of returned strings, either WIDE or ABBREVIATED. There 390 * are no NARROW quarters. 391 * @stable ICU 3.6 392 */ 393 void setQuarters(const UnicodeString* quarters, int32_t count, DtContextType context, DtWidthType width); 394 395 /** 396 * Gets AM/PM strings. For example: "AM" and "PM". 397 * @param count Filled in with length of the array. 398 * @return the weekday strings. (DateFormatSymbols retains ownership.) 399 * @stable ICU 2.0 400 */ 401 const UnicodeString* getAmPmStrings(int32_t& count) const; 402 403 /** 404 * Sets ampm strings. For example: "AM" and "PM". 405 * @param ampms the new ampm strings. (not adopted; caller retains ownership) 406 * @param count Filled in with length of the array. 407 * @stable ICU 2.0 408 */ 409 void setAmPmStrings(const UnicodeString* ampms, int32_t count); 410 411#ifndef U_HIDE_INTERNAL_API 412 /** 413 * This default time separator is used for formatting when the locale 414 * doesn't specify any time separator, and always recognized when parsing. 415 * @internal 416 */ 417 static const UChar DEFAULT_TIME_SEPARATOR = 0x003a; // ':' 418 419 /** 420 * This alternate time separator is always recognized when parsing. 421 * @internal 422 */ 423 static const UChar ALTERNATE_TIME_SEPARATOR = 0x002e; // '.' 424#endif /* U_HIDE_INTERNAL_API */ 425 426#ifndef U_HIDE_DRAFT_API 427 /** 428 * Gets the time separator string. For example: ":". 429 * @param result Output param which will receive the time separator string. 430 * @return A reference to 'result'. 431 * @draft ICU 55 432 */ 433 UnicodeString& getTimeSeparatorString(UnicodeString& result) const; 434 435 /** 436 * Sets the time separator string. For example: ":". 437 * @param newTimeSeparator the new time separator string. 438 * @draft ICU 55 439 */ 440 void setTimeSeparatorString(const UnicodeString& newTimeSeparator); 441#endif /* U_HIDE_DRAFT_API */ 442 443 /** 444 * Gets cyclic year name strings if the calendar has them, by width and context. 445 * For example: "jia-zi", "yi-chou", etc. 446 * @param count Filled in with length of the array. 447 * @param context The usage context: FORMAT, STANDALONE. 448 * @param width The requested name width: WIDE, ABBREVIATED, NARROW. 449 * @return The year name strings (DateFormatSymbols retains ownership), 450 * or null if they are not available for this calendar. 451 * @stable ICU 54 452 */ 453 const UnicodeString* getYearNames(int32_t& count, 454 DtContextType context, DtWidthType width) const; 455 456 /** 457 * Sets cyclic year name strings by width and context. For example: "jia-zi", "yi-chou", etc. 458 * 459 * @param yearNames The new cyclic year name strings (not adopted; caller retains ownership). 460 * @param count The length of the array. 461 * @param context The usage context: FORMAT, STANDALONE (currently only FORMAT is supported). 462 * @param width The name width: WIDE, ABBREVIATED, NARROW (currently only ABBREVIATED is supported). 463 * @stable ICU 54 464 */ 465 void setYearNames(const UnicodeString* yearNames, int32_t count, 466 DtContextType context, DtWidthType width); 467 468 /** 469 * Gets calendar zodiac name strings if the calendar has them, by width and context. 470 * For example: "Rat", "Ox", "Tiger", etc. 471 * @param count Filled in with length of the array. 472 * @param context The usage context: FORMAT, STANDALONE. 473 * @param width The requested name width: WIDE, ABBREVIATED, NARROW. 474 * @return The zodiac name strings (DateFormatSymbols retains ownership), 475 * or null if they are not available for this calendar. 476 * @stable ICU 54 477 */ 478 const UnicodeString* getZodiacNames(int32_t& count, 479 DtContextType context, DtWidthType width) const; 480 481 /** 482 * Sets calendar zodiac name strings by width and context. For example: "Rat", "Ox", "Tiger", etc. 483 * 484 * @param zodiacNames The new zodiac name strings (not adopted; caller retains ownership). 485 * @param count The length of the array. 486 * @param context The usage context: FORMAT, STANDALONE (currently only FORMAT is supported). 487 * @param width The name width: WIDE, ABBREVIATED, NARROW (currently only ABBREVIATED is supported). 488 * @stable ICU 54 489 */ 490 void setZodiacNames(const UnicodeString* zodiacNames, int32_t count, 491 DtContextType context, DtWidthType width); 492 493#ifndef U_HIDE_INTERNAL_API 494 /** 495 * Somewhat temporary constants for leap month pattern types, adequate for supporting 496 * just leap month patterns as needed for Chinese lunar calendar. 497 * Eventually we will add full support for different month pattern types (needed for 498 * other calendars such as Hindu) at which point this approach will be replaced by a 499 * more complete approach. 500 * @internal 501 */ 502 enum EMonthPatternType 503 { 504 kLeapMonthPatternFormatWide, 505 kLeapMonthPatternFormatAbbrev, 506 kLeapMonthPatternFormatNarrow, 507 kLeapMonthPatternStandaloneWide, 508 kLeapMonthPatternStandaloneAbbrev, 509 kLeapMonthPatternStandaloneNarrow, 510 kLeapMonthPatternNumeric, 511 kMonthPatternsCount 512 }; 513 514 /** 515 * Somewhat temporary function for getting complete set of leap month patterns for all 516 * contexts & widths, indexed by EMonthPatternType values. Returns NULL if calendar 517 * does not have leap month patterns. Note, there is currently no setter for this. 518 * Eventually we will add full support for different month pattern types (needed for 519 * other calendars such as Hindu) at which point this approach will be replaced by a 520 * more complete approach. 521 * @param count Filled in with length of the array (may be 0). 522 * @return The leap month patterns (DateFormatSymbols retains ownership). 523 * May be NULL if there are no leap month patterns for this calendar. 524 * @internal 525 */ 526 const UnicodeString* getLeapMonthPatterns(int32_t& count) const; 527 528#endif /* U_HIDE_INTERNAL_API */ 529 530#ifndef U_HIDE_DEPRECATED_API 531 /** 532 * Gets timezone strings. These strings are stored in a 2-dimensional array. 533 * @param rowCount Output param to receive number of rows. 534 * @param columnCount Output param to receive number of columns. 535 * @return The timezone strings as a 2-d array. (DateFormatSymbols retains ownership.) 536 * @deprecated ICU 3.6 537 */ 538 const UnicodeString** getZoneStrings(int32_t& rowCount, int32_t& columnCount) const; 539#endif /* U_HIDE_DEPRECATED_API */ 540 541 /** 542 * Sets timezone strings. These strings are stored in a 2-dimensional array. 543 * <p><b>Note:</b> SimpleDateFormat no longer use the zone strings stored in 544 * a DateFormatSymbols. Therefore, the time zone strings set by this mthod 545 * have no effects in an instance of SimpleDateFormat for formatting time 546 * zones. 547 * @param strings The timezone strings as a 2-d array to be copied. (not adopted; caller retains ownership) 548 * @param rowCount The number of rows (count of first index). 549 * @param columnCount The number of columns (count of second index). 550 * @stable ICU 2.0 551 */ 552 void setZoneStrings(const UnicodeString* const* strings, int32_t rowCount, int32_t columnCount); 553 554 /** 555 * Get the non-localized date-time pattern characters. 556 * @return the non-localized date-time pattern characters 557 * @stable ICU 2.0 558 */ 559 static const UChar * U_EXPORT2 getPatternUChars(void); 560 561 /** 562 * Gets localized date-time pattern characters. For example: 'u', 't', etc. 563 * <p> 564 * Note: ICU no longer provides localized date-time pattern characters for a locale 565 * starting ICU 3.8. This method returns the non-localized date-time pattern 566 * characters unless user defined localized data is set by setLocalPatternChars. 567 * @param result Output param which will receive the localized date-time pattern characters. 568 * @return A reference to 'result'. 569 * @stable ICU 2.0 570 */ 571 UnicodeString& getLocalPatternChars(UnicodeString& result) const; 572 573 /** 574 * Sets localized date-time pattern characters. For example: 'u', 't', etc. 575 * @param newLocalPatternChars the new localized date-time 576 * pattern characters. 577 * @stable ICU 2.0 578 */ 579 void setLocalPatternChars(const UnicodeString& newLocalPatternChars); 580 581 /** 582 * Returns the locale for this object. Two flavors are available: 583 * valid and actual locale. 584 * @stable ICU 2.8 585 */ 586 Locale getLocale(ULocDataLocaleType type, UErrorCode& status) const; 587 588 /* The following type and kCapContextUsageTypeCount cannot be #ifndef U_HIDE_INTERNAL_API, 589 they are needed for .h file declarations. */ 590 /** 591 * Constants for capitalization context usage types. 592 * @internal 593 */ 594 enum ECapitalizationContextUsageType 595 { 596#ifndef U_HIDE_INTERNAL_API 597 kCapContextUsageOther = 0, 598 kCapContextUsageMonthFormat, /* except narrow */ 599 kCapContextUsageMonthStandalone, /* except narrow */ 600 kCapContextUsageMonthNarrow, 601 kCapContextUsageDayFormat, /* except narrow */ 602 kCapContextUsageDayStandalone, /* except narrow */ 603 kCapContextUsageDayNarrow, 604 kCapContextUsageEraWide, 605 kCapContextUsageEraAbbrev, 606 kCapContextUsageEraNarrow, 607 kCapContextUsageZoneLong, 608 kCapContextUsageZoneShort, 609 kCapContextUsageMetazoneLong, 610 kCapContextUsageMetazoneShort, 611#endif /* U_HIDE_INTERNAL_API */ 612 kCapContextUsageTypeCount = 14 613 }; 614 615 /** 616 * ICU "poor man's RTTI", returns a UClassID for the actual class. 617 * 618 * @stable ICU 2.2 619 */ 620 virtual UClassID getDynamicClassID() const; 621 622 /** 623 * ICU "poor man's RTTI", returns a UClassID for this class. 624 * 625 * @stable ICU 2.2 626 */ 627 static UClassID U_EXPORT2 getStaticClassID(); 628 629private: 630 631 friend class SimpleDateFormat; 632 friend class DateFormatSymbolsSingleSetter; // see udat.cpp 633 634 /** 635 * Abbreviated era strings. For example: "AD" and "BC". 636 */ 637 UnicodeString* fEras; 638 int32_t fErasCount; 639 640 /** 641 * Era name strings. For example: "Anno Domini" and "Before Christ". 642 */ 643 UnicodeString* fEraNames; 644 int32_t fEraNamesCount; 645 646 /** 647 * Narrow era strings. For example: "A" and "B". 648 */ 649 UnicodeString* fNarrowEras; 650 int32_t fNarrowErasCount; 651 652 /** 653 * Month strings. For example: "January", "February", etc. 654 */ 655 UnicodeString* fMonths; 656 int32_t fMonthsCount; 657 658 /** 659 * Short month strings. For example: "Jan", "Feb", etc. 660 */ 661 UnicodeString* fShortMonths; 662 int32_t fShortMonthsCount; 663 664 /** 665 * Narrow month strings. For example: "J", "F", etc. 666 */ 667 UnicodeString* fNarrowMonths; 668 int32_t fNarrowMonthsCount; 669 670 /** 671 * Standalone Month strings. For example: "January", "February", etc. 672 */ 673 UnicodeString* fStandaloneMonths; 674 int32_t fStandaloneMonthsCount; 675 676 /** 677 * Standalone Short month strings. For example: "Jan", "Feb", etc. 678 */ 679 UnicodeString* fStandaloneShortMonths; 680 int32_t fStandaloneShortMonthsCount; 681 682 /** 683 * Standalone Narrow month strings. For example: "J", "F", etc. 684 */ 685 UnicodeString* fStandaloneNarrowMonths; 686 int32_t fStandaloneNarrowMonthsCount; 687 688 /** 689 * CLDR-style format wide weekday strings. For example: "Sunday", "Monday", etc. 690 */ 691 UnicodeString* fWeekdays; 692 int32_t fWeekdaysCount; 693 694 /** 695 * CLDR-style format abbreviated (not short) weekday strings. For example: "Sun", "Mon", etc. 696 */ 697 UnicodeString* fShortWeekdays; 698 int32_t fShortWeekdaysCount; 699 700 /** 701 * CLDR-style format short weekday strings. For example: "Su", "Mo", etc. 702 */ 703 UnicodeString* fShorterWeekdays; 704 int32_t fShorterWeekdaysCount; 705 706 /** 707 * CLDR-style format narrow weekday strings. For example: "S", "M", etc. 708 */ 709 UnicodeString* fNarrowWeekdays; 710 int32_t fNarrowWeekdaysCount; 711 712 /** 713 * CLDR-style standalone wide weekday strings. For example: "Sunday", "Monday", etc. 714 */ 715 UnicodeString* fStandaloneWeekdays; 716 int32_t fStandaloneWeekdaysCount; 717 718 /** 719 * CLDR-style standalone abbreviated (not short) weekday strings. For example: "Sun", "Mon", etc. 720 */ 721 UnicodeString* fStandaloneShortWeekdays; 722 int32_t fStandaloneShortWeekdaysCount; 723 724 /** 725 * CLDR-style standalone short weekday strings. For example: "Su", "Mo", etc. 726 */ 727 UnicodeString* fStandaloneShorterWeekdays; 728 int32_t fStandaloneShorterWeekdaysCount; 729 730 /** 731 * Standalone Narrow weekday strings. For example: "Sun", "Mon", etc. 732 */ 733 UnicodeString* fStandaloneNarrowWeekdays; 734 int32_t fStandaloneNarrowWeekdaysCount; 735 736 /** 737 * Ampm strings. For example: "AM" and "PM". 738 */ 739 UnicodeString* fAmPms; 740 int32_t fAmPmsCount; 741 742 /** 743 * Narrow Ampm strings. For example: "a" and "p". 744 */ 745 UnicodeString* fNarrowAmPms; 746 int32_t fNarrowAmPmsCount; 747 748 /** 749 * Time separator string. For example: ":". 750 */ 751 UnicodeString fTimeSeparator; 752 753 /** 754 * Quarter strings. For example: "1st quarter", "2nd quarter", etc. 755 */ 756 UnicodeString *fQuarters; 757 int32_t fQuartersCount; 758 759 /** 760 * Short quarters. For example: "Q1", "Q2", etc. 761 */ 762 UnicodeString *fShortQuarters; 763 int32_t fShortQuartersCount; 764 765 /** 766 * Standalone quarter strings. For example: "1st quarter", "2nd quarter", etc. 767 */ 768 UnicodeString *fStandaloneQuarters; 769 int32_t fStandaloneQuartersCount; 770 771 /** 772 * Standalone short quarter strings. For example: "Q1", "Q2", etc. 773 */ 774 UnicodeString *fStandaloneShortQuarters; 775 int32_t fStandaloneShortQuartersCount; 776 777 /** 778 * All leap month patterns, for example "{0}bis". 779 */ 780 UnicodeString *fLeapMonthPatterns; 781 int32_t fLeapMonthPatternsCount; 782 783 /** 784 * Cyclic year names, for example: "jia-zi", "yi-chou", ... "gui-hai"; 785 * currently we only have data for format/abbreviated. 786 * For the others, just get from format/abbreviated, ignore set. 787 */ 788 UnicodeString *fShortYearNames; 789 int32_t fShortYearNamesCount; 790 791 /** 792 * Cyclic zodiac names, for example "Rat", "Ox", "Tiger", etc.; 793 * currently we only have data for format/abbreviated. 794 * For the others, just get from format/abbreviated, ignore set. 795 */ 796 UnicodeString *fShortZodiacNames; 797 int32_t fShortZodiacNamesCount; 798 799 /** 800 * Localized names of time zones in this locale. This is a 801 * two-dimensional array of strings of size n by m, 802 * where m is at least 5 and up to 7. Each of the n rows is an 803 * entry containing the localized names for a single TimeZone. 804 * 805 * Each such row contains (with i ranging from 0..n-1): 806 * 807 * zoneStrings[i][0] - time zone ID 808 * example: America/Los_Angeles 809 * zoneStrings[i][1] - long name of zone in standard time 810 * example: Pacific Standard Time 811 * zoneStrings[i][2] - short name of zone in standard time 812 * example: PST 813 * zoneStrings[i][3] - long name of zone in daylight savings time 814 * example: Pacific Daylight Time 815 * zoneStrings[i][4] - short name of zone in daylight savings time 816 * example: PDT 817 * zoneStrings[i][5] - location name of zone 818 * example: United States (Los Angeles) 819 * zoneStrings[i][6] - long generic name of zone 820 * example: Pacific Time 821 * zoneStrings[i][7] - short generic of zone 822 * example: PT 823 * 824 * The zone ID is not localized; it corresponds to the ID 825 * value associated with a system time zone object. All other entries 826 * are localized names. If a zone does not implement daylight savings 827 * time, the daylight savings time names are ignored. 828 * 829 * Note:CLDR 1.5 introduced metazone and its historical mappings. 830 * This simple two-dimensional array is no longer sufficient to represent 831 * localized names and its historic changes. Since ICU 3.8.1, localized 832 * zone names extracted from ICU locale data is stored in a ZoneStringFormat 833 * instance. But we still need to support the old way of customizing 834 * localized zone names, so we keep this field for the purpose. 835 */ 836 UnicodeString **fZoneStrings; // Zone string array set by setZoneStrings 837 UnicodeString **fLocaleZoneStrings; // Zone string array created by the locale 838 int32_t fZoneStringsRowCount; 839 int32_t fZoneStringsColCount; 840 841 Locale fZSFLocale; // Locale used for getting ZoneStringFormat 842 843 /** 844 * Localized date-time pattern characters. For example: use 'u' as 'y'. 845 */ 846 UnicodeString fLocalPatternChars; 847 848 /** 849 * Capitalization transforms. For each usage type, the first array element indicates 850 * whether to titlecase for uiListOrMenu context, the second indicates whether to 851 * titlecase for stand-alone context. 852 */ 853 UBool fCapitalization[kCapContextUsageTypeCount][2]; 854 855private: 856 /** valid/actual locale information 857 * these are always ICU locales, so the length should not be a problem 858 */ 859 char validLocale[ULOC_FULLNAME_CAPACITY]; 860 char actualLocale[ULOC_FULLNAME_CAPACITY]; 861 862 DateFormatSymbols(); // default constructor not implemented 863 864 /** 865 * Called by the constructors to actually load data from the resources 866 * 867 * @param locale The locale to get symbols for. 868 * @param type Calendar Type (as from Calendar::getType()) 869 * @param status Input/output parameter, set to success or 870 * failure code upon return. 871 * @param useLastResortData determine if use last resort data 872 */ 873 void initializeData(const Locale& locale, const char *type, UErrorCode& status, UBool useLastResortData = FALSE); 874 875 /** 876 * Copy or alias an array in another object, as appropriate. 877 * 878 * @param dstArray the copy destination array. 879 * @param dstCount fill in with the lenth of 'dstArray'. 880 * @param srcArray the source array to be copied. 881 * @param srcCount the length of items to be copied from the 'srcArray'. 882 */ 883 static void assignArray(UnicodeString*& dstArray, 884 int32_t& dstCount, 885 const UnicodeString* srcArray, 886 int32_t srcCount); 887 888 /** 889 * Return true if the given arrays' contents are equal, or if the arrays are 890 * identical (pointers are equal). 891 * 892 * @param array1 one array to be compared with. 893 * @param array2 another array to be compared with. 894 * @param count the length of items to be copied. 895 * @return true if the given arrays' contents are equal, or if the arrays are 896 * identical (pointers are equal). 897 */ 898 static UBool arrayCompare(const UnicodeString* array1, 899 const UnicodeString* array2, 900 int32_t count); 901 902 /** 903 * Create a copy, in fZoneStrings, of the given zone strings array. The 904 * member variables fZoneStringsRowCount and fZoneStringsColCount should be 905 * set already by the caller. 906 */ 907 void createZoneStrings(const UnicodeString *const * otherStrings); 908 909 /** 910 * Delete all the storage owned by this object. 911 */ 912 void dispose(void); 913 914 /** 915 * Copy all of the other's data to this. 916 * @param other the object to be copied. 917 */ 918 void copyData(const DateFormatSymbols& other); 919 920 /** 921 * Create zone strings array by locale if not yet available 922 */ 923 void initZoneStringsArray(void); 924 925 /** 926 * Delete just the zone strings. 927 */ 928 void disposeZoneStrings(void); 929 930 /** 931 * Returns the date format field index of the pattern character c, 932 * or UDAT_FIELD_COUNT if c is not a pattern character. 933 */ 934 static UDateFormatField U_EXPORT2 getPatternCharIndex(UChar c); 935 936 /** 937 * Returns TRUE if f (with its pattern character repeated count times) is a numeric field. 938 */ 939 static UBool U_EXPORT2 isNumericField(UDateFormatField f, int32_t count); 940 941 /** 942 * Returns TRUE if c (repeated count times) is the pattern character for a numeric field. 943 */ 944 static UBool U_EXPORT2 isNumericPatternChar(UChar c, int32_t count); 945public: 946#ifndef U_HIDE_INTERNAL_API 947 /** 948 * Gets a DateFormatSymbols by locale. 949 * Unlike the constructors which always use gregorian calendar, this 950 * method uses the calendar in the locale. If the locale contains no 951 * explicit calendar, this method uses the default calendar for that 952 * locale. 953 * @param locale the locale. 954 * @param status error returned here. 955 * @return the new DateFormatSymbols which the caller owns. 956 * @internal For ICU use only. 957 */ 958 static DateFormatSymbols * U_EXPORT2 createForLocale( 959 const Locale &locale, UErrorCode &status); 960#endif /* U_HIDE_INTERNAL_API */ 961}; 962 963U_NAMESPACE_END 964 965#endif /* #if !UCONFIG_NO_FORMATTING */ 966 967#endif // _DTFMTSYM 968//eof 969