1 // © 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ******************************************************************************* 5 * Copyright (C) 2007-2016, International Business Machines Corporation and 6 * others. All Rights Reserved. 7 ******************************************************************************* 8 * 9 * File DTPTNGEN.H 10 * 11 ******************************************************************************* 12 */ 13 14 #ifndef __DTPTNGEN_H__ 15 #define __DTPTNGEN_H__ 16 17 #include "unicode/utypes.h" 18 19 #if U_SHOW_CPLUSPLUS_API 20 21 #include "unicode/datefmt.h" 22 #include "unicode/locid.h" 23 #include "unicode/udat.h" 24 #include "unicode/udatpg.h" 25 #include "unicode/unistr.h" 26 27 U_NAMESPACE_BEGIN 28 29 /** 30 * \file 31 * \brief C++ API: Date/Time Pattern Generator 32 */ 33 34 35 class CharString; 36 class Hashtable; 37 class FormatParser; 38 class DateTimeMatcher; 39 class DistanceInfo; 40 class PatternMap; 41 class PtnSkeleton; 42 class SharedDateTimePatternGenerator; 43 44 /** 45 * This class provides flexible generation of date format patterns, like "yy-MM-dd". 46 * The user can build up the generator by adding successive patterns. Once that 47 * is done, a query can be made using a "skeleton", which is a pattern which just 48 * includes the desired fields and lengths. The generator will return the "best fit" 49 * pattern corresponding to that skeleton. 50 * <p>The main method people will use is getBestPattern(String skeleton), 51 * since normally this class is pre-built with data from a particular locale. 52 * However, generators can be built directly from other data as well. 53 * <p><i>Issue: may be useful to also have a function that returns the list of 54 * fields in a pattern, in order, since we have that internally. 55 * That would be useful for getting the UI order of field elements.</i> 56 * @stable ICU 3.8 57 **/ 58 class U_I18N_API DateTimePatternGenerator : public UObject { 59 public: 60 /** 61 * Construct a flexible generator according to default locale. 62 * @param status Output param set to success/failure code on exit, 63 * which must not indicate a failure before the function call. 64 * @stable ICU 3.8 65 */ 66 static DateTimePatternGenerator* U_EXPORT2 createInstance(UErrorCode& status); 67 68 /** 69 * Construct a flexible generator according to data for a given locale. 70 * @param uLocale 71 * @param status Output param set to success/failure code on exit, 72 * which must not indicate a failure before the function call. 73 * @stable ICU 3.8 74 */ 75 static DateTimePatternGenerator* U_EXPORT2 createInstance(const Locale& uLocale, UErrorCode& status); 76 77 #ifndef U_HIDE_INTERNAL_API 78 79 /** 80 * For ICU use only. Skips loading the standard date/time patterns (which is done via DateFormat). 81 * 82 * @internal 83 */ 84 static DateTimePatternGenerator* U_EXPORT2 createInstanceNoStdPat(const Locale& uLocale, UErrorCode& status); 85 86 #endif /* U_HIDE_INTERNAL_API */ 87 88 /** 89 * Create an empty generator, to be constructed with addPattern(...) etc. 90 * @param status Output param set to success/failure code on exit, 91 * which must not indicate a failure before the function call. 92 * @stable ICU 3.8 93 */ 94 static DateTimePatternGenerator* U_EXPORT2 createEmptyInstance(UErrorCode& status); 95 96 /** 97 * Destructor. 98 * @stable ICU 3.8 99 */ 100 virtual ~DateTimePatternGenerator(); 101 102 /** 103 * Clone DateTimePatternGenerator object. Clients are responsible for 104 * deleting the DateTimePatternGenerator object cloned. 105 * @stable ICU 3.8 106 */ 107 DateTimePatternGenerator* clone() const; 108 109 /** 110 * Return true if another object is semantically equal to this one. 111 * 112 * @param other the DateTimePatternGenerator object to be compared with. 113 * @return true if other is semantically equal to this. 114 * @stable ICU 3.8 115 */ 116 bool operator==(const DateTimePatternGenerator& other) const; 117 118 /** 119 * Return true if another object is semantically unequal to this one. 120 * 121 * @param other the DateTimePatternGenerator object to be compared with. 122 * @return true if other is semantically unequal to this. 123 * @stable ICU 3.8 124 */ 125 bool operator!=(const DateTimePatternGenerator& other) const; 126 127 /** 128 * Utility to return a unique skeleton from a given pattern. For example, 129 * both "MMM-dd" and "dd/MMM" produce the skeleton "MMMdd". 130 * 131 * @param pattern Input pattern, such as "dd/MMM" 132 * @param status Output param set to success/failure code on exit, 133 * which must not indicate a failure before the function call. 134 * @return skeleton such as "MMMdd" 135 * @stable ICU 56 136 */ 137 static UnicodeString staticGetSkeleton(const UnicodeString& pattern, UErrorCode& status); 138 139 /** 140 * Utility to return a unique skeleton from a given pattern. For example, 141 * both "MMM-dd" and "dd/MMM" produce the skeleton "MMMdd". 142 * getSkeleton() works exactly like staticGetSkeleton(). 143 * Use staticGetSkeleton() instead of getSkeleton(). 144 * 145 * @param pattern Input pattern, such as "dd/MMM" 146 * @param status Output param set to success/failure code on exit, 147 * which must not indicate a failure before the function call. 148 * @return skeleton such as "MMMdd" 149 * @stable ICU 3.8 150 */ 151 UnicodeString getSkeleton(const UnicodeString& pattern, UErrorCode& status); /* { 152 The function is commented out because it is a stable API calling a draft API. 153 After staticGetSkeleton becomes stable, staticGetSkeleton can be used and 154 these comments and the definition of getSkeleton in dtptngen.cpp should be removed. 155 return staticGetSkeleton(pattern, status); 156 }*/ 157 158 /** 159 * Utility to return a unique base skeleton from a given pattern. This is 160 * the same as the skeleton, except that differences in length are minimized 161 * so as to only preserve the difference between string and numeric form. So 162 * for example, both "MMM-dd" and "d/MMM" produce the skeleton "MMMd" 163 * (notice the single d). 164 * 165 * @param pattern Input pattern, such as "dd/MMM" 166 * @param status Output param set to success/failure code on exit, 167 * which must not indicate a failure before the function call. 168 * @return base skeleton, such as "MMMd" 169 * @stable ICU 56 170 */ 171 static UnicodeString staticGetBaseSkeleton(const UnicodeString& pattern, UErrorCode& status); 172 173 /** 174 * Utility to return a unique base skeleton from a given pattern. This is 175 * the same as the skeleton, except that differences in length are minimized 176 * so as to only preserve the difference between string and numeric form. So 177 * for example, both "MMM-dd" and "d/MMM" produce the skeleton "MMMd" 178 * (notice the single d). 179 * getBaseSkeleton() works exactly like staticGetBaseSkeleton(). 180 * Use staticGetBaseSkeleton() instead of getBaseSkeleton(). 181 * 182 * @param pattern Input pattern, such as "dd/MMM" 183 * @param status Output param set to success/failure code on exit, 184 * which must not indicate a failure before the function call. 185 * @return base skeleton, such as "MMMd" 186 * @stable ICU 3.8 187 */ 188 UnicodeString getBaseSkeleton(const UnicodeString& pattern, UErrorCode& status); /* { 189 The function is commented out because it is a stable API calling a draft API. 190 After staticGetBaseSkeleton becomes stable, staticGetBaseSkeleton can be used and 191 these comments and the definition of getBaseSkeleton in dtptngen.cpp should be removed. 192 return staticGetBaseSkeleton(pattern, status); 193 }*/ 194 195 /** 196 * Adds a pattern to the generator. If the pattern has the same skeleton as 197 * an existing pattern, and the override parameter is set, then the previous 198 * value is overridden. Otherwise, the previous value is retained. In either 199 * case, the conflicting status is set and previous vale is stored in 200 * conflicting pattern. 201 * <p> 202 * Note that single-field patterns (like "MMM") are automatically added, and 203 * don't need to be added explicitly! 204 * 205 * @param pattern Input pattern, such as "dd/MMM" 206 * @param override When existing values are to be overridden use true, 207 * otherwise use false. 208 * @param conflictingPattern Previous pattern with the same skeleton. 209 * @param status Output param set to success/failure code on exit, 210 * which must not indicate a failure before the function call. 211 * @return conflicting status. The value could be UDATPG_NO_CONFLICT, 212 * UDATPG_BASE_CONFLICT or UDATPG_CONFLICT. 213 * @stable ICU 3.8 214 * <p> 215 * <h4>Sample code</h4> 216 * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample1 217 * \snippet samples/dtptngsample/dtptngsample.cpp addPatternExample 218 * <p> 219 */ 220 UDateTimePatternConflict addPattern(const UnicodeString& pattern, 221 UBool override, 222 UnicodeString& conflictingPattern, 223 UErrorCode& status); 224 225 /** 226 * An AppendItem format is a pattern used to append a field if there is no 227 * good match. For example, suppose that the input skeleton is "GyyyyMMMd", 228 * and there is no matching pattern internally, but there is a pattern 229 * matching "yyyyMMMd", say "d-MM-yyyy". Then that pattern is used, plus the 230 * G. The way these two are conjoined is by using the AppendItemFormat for G 231 * (era). So if that value is, say "{0}, {1}" then the final resulting 232 * pattern is "d-MM-yyyy, G". 233 * <p> 234 * There are actually three available variables: {0} is the pattern so far, 235 * {1} is the element we are adding, and {2} is the name of the element. 236 * <p> 237 * This reflects the way that the CLDR data is organized. 238 * 239 * @param field such as UDATPG_ERA_FIELD. 240 * @param value pattern, such as "{0}, {1}" 241 * @stable ICU 3.8 242 */ 243 void setAppendItemFormat(UDateTimePatternField field, const UnicodeString& value); 244 245 /** 246 * Getter corresponding to setAppendItemFormat. Values below 0 or at or 247 * above UDATPG_FIELD_COUNT are illegal arguments. 248 * 249 * @param field such as UDATPG_ERA_FIELD. 250 * @return append pattern for field 251 * @stable ICU 3.8 252 */ 253 const UnicodeString& getAppendItemFormat(UDateTimePatternField field) const; 254 255 /** 256 * Sets the names of field, eg "era" in English for ERA. These are only 257 * used if the corresponding AppendItemFormat is used, and if it contains a 258 * {2} variable. 259 * <p> 260 * This reflects the way that the CLDR data is organized. 261 * 262 * @param field such as UDATPG_ERA_FIELD. 263 * @param value name of the field 264 * @stable ICU 3.8 265 */ 266 void setAppendItemName(UDateTimePatternField field, const UnicodeString& value); 267 268 /** 269 * Getter corresponding to setAppendItemNames. Values below 0 or at or above 270 * UDATPG_FIELD_COUNT are illegal arguments. Note: The more general method 271 * for getting date/time field display names is getFieldDisplayName. 272 * 273 * @param field such as UDATPG_ERA_FIELD. 274 * @return name for field 275 * @see getFieldDisplayName 276 * @stable ICU 3.8 277 */ 278 const UnicodeString& getAppendItemName(UDateTimePatternField field) const; 279 280 /** 281 * The general interface to get a display name for a particular date/time field, 282 * in one of several possible display widths. 283 * 284 * @param field The desired UDateTimePatternField, such as UDATPG_ERA_FIELD. 285 * @param width The desired UDateTimePGDisplayWidth, such as UDATPG_ABBREVIATED. 286 * @return The display name for field 287 * @stable ICU 61 288 */ 289 UnicodeString getFieldDisplayName(UDateTimePatternField field, UDateTimePGDisplayWidth width) const; 290 291 /** 292 * The DateTimeFormat is a message format pattern used to compose date and 293 * time patterns. The default pattern in the root locale is "{1} {0}", where 294 * {1} will be replaced by the date pattern and {0} will be replaced by the 295 * time pattern; however, other locales may specify patterns such as 296 * "{1}, {0}" or "{1} 'at' {0}", etc. 297 * <p> 298 * This is used when the input skeleton contains both date and time fields, 299 * but there is not a close match among the added patterns. For example, 300 * suppose that this object was created by adding "dd-MMM" and "hh:mm", and 301 * its datetimeFormat is the default "{1} {0}". Then if the input skeleton 302 * is "MMMdhmm", there is not an exact match, so the input skeleton is 303 * broken up into two components "MMMd" and "hmm". There are close matches 304 * for those two skeletons, so the result is put together with this pattern, 305 * resulting in "d-MMM h:mm". 306 * 307 * There are four DateTimeFormats in a DateTimePatternGenerator object, 308 * corresponding to date styles UDAT_FULL..UDAT_SHORT. This method sets 309 * all of them to the specified pattern. To set them individually, see 310 * setDateTimeFormat(UDateFormatStyle style, ...). 311 * 312 * @param dateTimeFormat 313 * message format pattern, here {1} will be replaced by the date 314 * pattern and {0} will be replaced by the time pattern. 315 * @stable ICU 3.8 316 */ 317 void setDateTimeFormat(const UnicodeString& dateTimeFormat); 318 319 /** 320 * Getter corresponding to setDateTimeFormat. 321 * 322 * There are four DateTimeFormats in a DateTimePatternGenerator object, 323 * corresponding to date styles UDAT_FULL..UDAT_SHORT. This method gets 324 * the style for UDAT_MEDIUM (the default). To get them individually, see 325 * getDateTimeFormat(UDateFormatStyle style). 326 * 327 * @return DateTimeFormat. 328 * @stable ICU 3.8 329 */ 330 const UnicodeString& getDateTimeFormat() const; 331 332 #if !UCONFIG_NO_FORMATTING 333 /** 334 * dateTimeFormats are message patterns used to compose combinations of date 335 * and time patterns. There are four length styles, corresponding to the 336 * inferred style of the date pattern; these are UDateFormatStyle values: 337 * - UDAT_FULL (for date pattern with weekday and long month), else 338 * - UDAT_LONG (for a date pattern with long month), else 339 * - UDAT_MEDIUM (for a date pattern with abbreviated month), else 340 * - UDAT_SHORT (for any other date pattern). 341 * For details on dateTimeFormats, see 342 * https://www.unicode.org/reports/tr35/tr35-dates.html#dateTimeFormats. 343 * The default pattern in the root locale for all styles is "{1} {0}". 344 * 345 * @param style 346 * one of DateFormat.FULL..DateFormat.SHORT. Error if out of range. 347 * @param dateTimeFormat 348 * the new dateTimeFormat to set for the the specified style 349 * @param status 350 * in/out parameter; if no failure status is already set, 351 * it will be set according to result of the function (e.g. 352 * U_ILLEGAL_ARGUMENT_ERROR for style out of range). 353 * @stable ICU 71 354 */ 355 void setDateTimeFormat(UDateFormatStyle style, const UnicodeString& dateTimeFormat, 356 UErrorCode& status); 357 358 /** 359 * Getter corresponding to setDateTimeFormat. 360 * 361 * @param style 362 * one of UDAT_FULL..UDAT_SHORT. Error if out of range. 363 * @param status 364 * in/out parameter; if no failure status is already set, 365 * it will be set according to result of the function (e.g. 366 * U_ILLEGAL_ARGUMENT_ERROR for style out of range). 367 * @return 368 * the current dateTimeFormat for the the specified style, or 369 * empty string in case of error. The UnicodeString reference, 370 * or the contents of the string, may no longer be valid if 371 * setDateTimeFormat is called, or the DateTimePatternGenerator 372 * object is deleted. 373 * @stable ICU 71 374 */ 375 const UnicodeString& getDateTimeFormat(UDateFormatStyle style, 376 UErrorCode& status) const; 377 #endif /* #if !UCONFIG_NO_FORMATTING */ 378 379 /** 380 * Return the best pattern matching the input skeleton. It is guaranteed to 381 * have all of the fields in the skeleton. 382 * 383 * @param skeleton 384 * The skeleton is a pattern containing only the variable fields. 385 * For example, "MMMdd" and "mmhh" are skeletons. 386 * @param status Output param set to success/failure code on exit, 387 * which must not indicate a failure before the function call. 388 * @return bestPattern 389 * The best pattern found from the given skeleton. 390 * @stable ICU 3.8 391 * <p> 392 * <h4>Sample code</h4> 393 * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample1 394 * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample 395 * <p> 396 */ 397 UnicodeString getBestPattern(const UnicodeString& skeleton, UErrorCode& status); 398 399 400 /** 401 * Return the best pattern matching the input skeleton. It is guaranteed to 402 * have all of the fields in the skeleton. 403 * 404 * @param skeleton 405 * The skeleton is a pattern containing only the variable fields. 406 * For example, "MMMdd" and "mmhh" are skeletons. 407 * @param options 408 * Options for forcing the length of specified fields in the 409 * returned pattern to match those in the skeleton (when this 410 * would not happen otherwise). For default behavior, use 411 * UDATPG_MATCH_NO_OPTIONS. 412 * @param status 413 * Output param set to success/failure code on exit, 414 * which must not indicate a failure before the function call. 415 * @return bestPattern 416 * The best pattern found from the given skeleton. 417 * @stable ICU 4.4 418 */ 419 UnicodeString getBestPattern(const UnicodeString& skeleton, 420 UDateTimePatternMatchOptions options, 421 UErrorCode& status); 422 423 424 /** 425 * Adjusts the field types (width and subtype) of a pattern to match what is 426 * in a skeleton. That is, if you supply a pattern like "d-M H:m", and a 427 * skeleton of "MMMMddhhmm", then the input pattern is adjusted to be 428 * "dd-MMMM hh:mm". This is used internally to get the best match for the 429 * input skeleton, but can also be used externally. 430 * 431 * @param pattern Input pattern 432 * @param skeleton 433 * The skeleton is a pattern containing only the variable fields. 434 * For example, "MMMdd" and "mmhh" are skeletons. 435 * @param status Output param set to success/failure code on exit, 436 * which must not indicate a failure before the function call. 437 * @return pattern adjusted to match the skeleton fields widths and subtypes. 438 * @stable ICU 3.8 439 * <p> 440 * <h4>Sample code</h4> 441 * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample1 442 * \snippet samples/dtptngsample/dtptngsample.cpp replaceFieldTypesExample 443 * <p> 444 */ 445 UnicodeString replaceFieldTypes(const UnicodeString& pattern, 446 const UnicodeString& skeleton, 447 UErrorCode& status); 448 449 /** 450 * Adjusts the field types (width and subtype) of a pattern to match what is 451 * in a skeleton. That is, if you supply a pattern like "d-M H:m", and a 452 * skeleton of "MMMMddhhmm", then the input pattern is adjusted to be 453 * "dd-MMMM hh:mm". This is used internally to get the best match for the 454 * input skeleton, but can also be used externally. 455 * 456 * @param pattern Input pattern 457 * @param skeleton 458 * The skeleton is a pattern containing only the variable fields. 459 * For example, "MMMdd" and "mmhh" are skeletons. 460 * @param options 461 * Options controlling whether the length of specified fields in the 462 * pattern are adjusted to match those in the skeleton (when this 463 * would not happen otherwise). For default behavior, use 464 * UDATPG_MATCH_NO_OPTIONS. 465 * @param status 466 * Output param set to success/failure code on exit, 467 * which must not indicate a failure before the function call. 468 * @return pattern adjusted to match the skeleton fields widths and subtypes. 469 * @stable ICU 4.4 470 */ 471 UnicodeString replaceFieldTypes(const UnicodeString& pattern, 472 const UnicodeString& skeleton, 473 UDateTimePatternMatchOptions options, 474 UErrorCode& status); 475 476 /** 477 * Return a list of all the skeletons (in canonical form) from this class. 478 * 479 * Call getPatternForSkeleton() to get the corresponding pattern. 480 * 481 * @param status Output param set to success/failure code on exit, 482 * which must not indicate a failure before the function call. 483 * @return StringEnumeration with the skeletons. 484 * The caller must delete the object. 485 * @stable ICU 3.8 486 */ 487 StringEnumeration* getSkeletons(UErrorCode& status) const; 488 489 /** 490 * Get the pattern corresponding to a given skeleton. 491 * @param skeleton 492 * @return pattern corresponding to a given skeleton. 493 * @stable ICU 3.8 494 */ 495 const UnicodeString& getPatternForSkeleton(const UnicodeString& skeleton) const; 496 497 /** 498 * Return a list of all the base skeletons (in canonical form) from this class. 499 * 500 * @param status Output param set to success/failure code on exit, 501 * which must not indicate a failure before the function call. 502 * @return a StringEnumeration with the base skeletons. 503 * The caller must delete the object. 504 * @stable ICU 3.8 505 */ 506 StringEnumeration* getBaseSkeletons(UErrorCode& status) const; 507 508 #ifndef U_HIDE_INTERNAL_API 509 /** 510 * Return a list of redundant patterns are those which if removed, make no 511 * difference in the resulting getBestPattern values. This method returns a 512 * list of them, to help check the consistency of the patterns used to build 513 * this generator. 514 * 515 * @param status Output param set to success/failure code on exit, 516 * which must not indicate a failure before the function call. 517 * @return a StringEnumeration with the redundant pattern. 518 * The caller must delete the object. 519 * @internal ICU 3.8 520 */ 521 StringEnumeration* getRedundants(UErrorCode& status); 522 #endif /* U_HIDE_INTERNAL_API */ 523 524 /** 525 * The decimal value is used in formatting fractions of seconds. If the 526 * skeleton contains fractional seconds, then this is used with the 527 * fractional seconds. For example, suppose that the input pattern is 528 * "hhmmssSSSS", and the best matching pattern internally is "H:mm:ss", and 529 * the decimal string is ",". Then the resulting pattern is modified to be 530 * "H:mm:ss,SSSS" 531 * 532 * @param decimal 533 * @stable ICU 3.8 534 */ 535 void setDecimal(const UnicodeString& decimal); 536 537 /** 538 * Getter corresponding to setDecimal. 539 * @return UnicodeString corresponding to the decimal point 540 * @stable ICU 3.8 541 */ 542 const UnicodeString& getDecimal() const; 543 544 #if !UCONFIG_NO_FORMATTING 545 546 /** 547 * Get the default hour cycle for a locale. Uses the locale that the 548 * DateTimePatternGenerator was initially created with. 549 * 550 * Cannot be used on an empty DateTimePatternGenerator instance. 551 * 552 * @param status Output param set to success/failure code on exit, which 553 * which must not indicate a failure before the function call. 554 * Set to U_UNSUPPORTED_ERROR if used on an empty instance. 555 * @return the default hour cycle. 556 * @stable ICU 67 557 */ 558 UDateFormatHourCycle getDefaultHourCycle(UErrorCode& status) const; 559 560 #endif /* #if !UCONFIG_NO_FORMATTING */ 561 562 /** 563 * ICU "poor man's RTTI", returns a UClassID for the actual class. 564 * 565 * @stable ICU 3.8 566 */ 567 virtual UClassID getDynamicClassID() const override; 568 569 /** 570 * ICU "poor man's RTTI", returns a UClassID for this class. 571 * 572 * @stable ICU 3.8 573 */ 574 static UClassID U_EXPORT2 getStaticClassID(void); 575 576 private: 577 /** 578 * Constructor. 579 */ 580 DateTimePatternGenerator(UErrorCode & status); 581 582 /** 583 * Constructor. 584 */ 585 DateTimePatternGenerator(const Locale& locale, UErrorCode & status, UBool skipStdPatterns = false); 586 587 /** 588 * Copy constructor. 589 * @param other DateTimePatternGenerator to copy 590 */ 591 DateTimePatternGenerator(const DateTimePatternGenerator& other); 592 593 /** 594 * Default assignment operator. 595 * @param other DateTimePatternGenerator to copy 596 */ 597 DateTimePatternGenerator& operator=(const DateTimePatternGenerator& other); 598 599 static const int32_t UDATPG_WIDTH_COUNT = UDATPG_NARROW + 1; 600 601 Locale pLocale; // pattern locale 602 FormatParser *fp; 603 DateTimeMatcher* dtMatcher; 604 DistanceInfo *distanceInfo; 605 PatternMap *patternMap; 606 UnicodeString appendItemFormats[UDATPG_FIELD_COUNT]; 607 UnicodeString fieldDisplayNames[UDATPG_FIELD_COUNT][UDATPG_WIDTH_COUNT]; 608 UnicodeString dateTimeFormat[4]; 609 UnicodeString decimal; 610 DateTimeMatcher *skipMatcher; 611 Hashtable *fAvailableFormatKeyHash; 612 UnicodeString emptyString; 613 char16_t fDefaultHourFormatChar; 614 615 int32_t fAllowedHourFormats[7]; // Actually an array of AllowedHourFormat enum type, ending with UNKNOWN. 616 617 // Internal error code used for recording/reporting errors that occur during methods that do not 618 // have a UErrorCode parameter. For example: the Copy Constructor, or the ::clone() method. 619 // When this is set to an error the object is in an invalid state. 620 UErrorCode internalErrorCode; 621 622 /* internal flags masks for adjustFieldTypes etc. */ 623 enum { 624 kDTPGNoFlags = 0, 625 kDTPGFixFractionalSeconds = 1, 626 kDTPGSkeletonUsesCapJ = 2 627 // with #13183, no longer need flags for b, B 628 }; 629 630 void initData(const Locale &locale, UErrorCode &status, UBool skipStdPatterns = false); 631 void addCanonicalItems(UErrorCode &status); 632 void addICUPatterns(const Locale& locale, UErrorCode& status); 633 void hackTimes(const UnicodeString& hackPattern, UErrorCode& status); 634 void getCalendarTypeToUse(const Locale& locale, CharString& destination, UErrorCode& err); 635 void consumeShortTimePattern(const UnicodeString& shortTimePattern, UErrorCode& status); 636 void addCLDRData(const Locale& locale, UErrorCode& status); 637 UDateTimePatternConflict addPatternWithSkeleton(const UnicodeString& pattern, const UnicodeString * skeletonToUse, UBool override, UnicodeString& conflictingPattern, UErrorCode& status); 638 void initHashtable(UErrorCode& status); 639 void setDateTimeFromCalendar(const Locale& locale, UErrorCode& status); 640 void setDecimalSymbols(const Locale& locale, UErrorCode& status); 641 UDateTimePatternField getAppendFormatNumber(const char* field) const; 642 // Note for the next 3: UDateTimePGDisplayWidth is now stable ICU 61 643 UDateTimePatternField getFieldAndWidthIndices(const char* key, UDateTimePGDisplayWidth* widthP) const; 644 void setFieldDisplayName(UDateTimePatternField field, UDateTimePGDisplayWidth width, const UnicodeString& value); 645 UnicodeString& getMutableFieldDisplayName(UDateTimePatternField field, UDateTimePGDisplayWidth width); 646 void getAppendName(UDateTimePatternField field, UnicodeString& value); 647 UnicodeString mapSkeletonMetacharacters(const UnicodeString& patternForm, int32_t* flags, UErrorCode& status); 648 const UnicodeString* getBestRaw(DateTimeMatcher& source, int32_t includeMask, DistanceInfo* missingFields, UErrorCode& status, const PtnSkeleton** specifiedSkeletonPtr = 0); 649 UnicodeString adjustFieldTypes(const UnicodeString& pattern, const PtnSkeleton* specifiedSkeleton, int32_t flags, UDateTimePatternMatchOptions options = UDATPG_MATCH_NO_OPTIONS); 650 UnicodeString getBestAppending(int32_t missingFields, int32_t flags, UErrorCode& status, UDateTimePatternMatchOptions options = UDATPG_MATCH_NO_OPTIONS); 651 int32_t getTopBitNumber(int32_t foundMask) const; 652 void setAvailableFormat(const UnicodeString &key, UErrorCode& status); 653 UBool isAvailableFormatSet(const UnicodeString &key) const; 654 void copyHashtable(Hashtable *other, UErrorCode &status); 655 UBool isCanonicalItem(const UnicodeString& item) const; 656 static void U_CALLCONV loadAllowedHourFormatsData(UErrorCode &status); 657 void getAllowedHourFormats(const Locale &locale, UErrorCode &status); 658 659 struct U_HIDDEN AppendItemFormatsSink; 660 struct U_HIDDEN AppendItemNamesSink; 661 struct U_HIDDEN AvailableFormatsSink; 662 } ;// end class DateTimePatternGenerator 663 664 U_NAMESPACE_END 665 666 #endif /* U_SHOW_CPLUSPLUS_API */ 667 668 #endif 669