"Fossies" - the Fresh Open Source Software Archive

Member "icu/source/i18n/unicode/dtptngen.h" (22 Apr 2020, 26419 Bytes) of package /linux/misc/icu4c-67_1-src.tgz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "dtptngen.h" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes reports: 67rc_vs_67_1 or 66_1_vs_67_1.

    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
   81      *
   82      * @internal
   83      */
   84     static DateTimePatternGenerator* U_EXPORT2 internalMakeInstance(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     UBool 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     UBool 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 overriden. 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      * @param dateTimeFormat
  308      *            message format pattern, here {1} will be replaced by the date
  309      *            pattern and {0} will be replaced by the time pattern.
  310      * @stable ICU 3.8
  311      */
  312     void setDateTimeFormat(const UnicodeString& dateTimeFormat);
  313 
  314     /**
  315      * Getter corresponding to setDateTimeFormat.
  316      * @return DateTimeFormat.
  317      * @stable ICU 3.8
  318      */
  319     const UnicodeString& getDateTimeFormat() const;
  320 
  321     /**
  322      * Return the best pattern matching the input skeleton. It is guaranteed to
  323      * have all of the fields in the skeleton.
  324      *
  325      * @param skeleton
  326      *            The skeleton is a pattern containing only the variable fields.
  327      *            For example, "MMMdd" and "mmhh" are skeletons.
  328      * @param status  Output param set to success/failure code on exit,
  329      *               which must not indicate a failure before the function call.
  330      * @return bestPattern
  331      *            The best pattern found from the given skeleton.
  332      * @stable ICU 3.8
  333      * <p>
  334      * <h4>Sample code</h4>
  335      * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample1
  336      * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample
  337      * <p>
  338      */
  339      UnicodeString getBestPattern(const UnicodeString& skeleton, UErrorCode& status);
  340 
  341 
  342     /**
  343      * Return the best pattern matching the input skeleton. It is guaranteed to
  344      * have all of the fields in the skeleton.
  345      *
  346      * @param skeleton
  347      *            The skeleton is a pattern containing only the variable fields.
  348      *            For example, "MMMdd" and "mmhh" are skeletons.
  349      * @param options
  350      *            Options for forcing the length of specified fields in the
  351      *            returned pattern to match those in the skeleton (when this
  352      *            would not happen otherwise). For default behavior, use
  353      *            UDATPG_MATCH_NO_OPTIONS.
  354      * @param status
  355      *            Output param set to success/failure code on exit,
  356      *            which must not indicate a failure before the function call.
  357      * @return bestPattern
  358      *            The best pattern found from the given skeleton.
  359      * @stable ICU 4.4
  360      */
  361      UnicodeString getBestPattern(const UnicodeString& skeleton,
  362                                   UDateTimePatternMatchOptions options,
  363                                   UErrorCode& status);
  364 
  365 
  366     /**
  367      * Adjusts the field types (width and subtype) of a pattern to match what is
  368      * in a skeleton. That is, if you supply a pattern like "d-M H:m", and a
  369      * skeleton of "MMMMddhhmm", then the input pattern is adjusted to be
  370      * "dd-MMMM hh:mm". This is used internally to get the best match for the
  371      * input skeleton, but can also be used externally.
  372      *
  373      * @param pattern Input pattern
  374      * @param skeleton
  375      *            The skeleton is a pattern containing only the variable fields.
  376      *            For example, "MMMdd" and "mmhh" are skeletons.
  377      * @param status  Output param set to success/failure code on exit,
  378      *               which must not indicate a failure before the function call.
  379      * @return pattern adjusted to match the skeleton fields widths and subtypes.
  380      * @stable ICU 3.8
  381      * <p>
  382      * <h4>Sample code</h4>
  383      * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample1
  384      * \snippet samples/dtptngsample/dtptngsample.cpp replaceFieldTypesExample
  385      * <p>
  386      */
  387      UnicodeString replaceFieldTypes(const UnicodeString& pattern,
  388                                      const UnicodeString& skeleton,
  389                                      UErrorCode& status);
  390 
  391     /**
  392      * Adjusts the field types (width and subtype) of a pattern to match what is
  393      * in a skeleton. That is, if you supply a pattern like "d-M H:m", and a
  394      * skeleton of "MMMMddhhmm", then the input pattern is adjusted to be
  395      * "dd-MMMM hh:mm". This is used internally to get the best match for the
  396      * input skeleton, but can also be used externally.
  397      *
  398      * @param pattern Input pattern
  399      * @param skeleton
  400      *            The skeleton is a pattern containing only the variable fields.
  401      *            For example, "MMMdd" and "mmhh" are skeletons.
  402      * @param options
  403      *            Options controlling whether the length of specified fields in the
  404      *            pattern are adjusted to match those in the skeleton (when this
  405      *            would not happen otherwise). For default behavior, use
  406      *            UDATPG_MATCH_NO_OPTIONS.
  407      * @param status
  408      *            Output param set to success/failure code on exit,
  409      *            which must not indicate a failure before the function call.
  410      * @return pattern adjusted to match the skeleton fields widths and subtypes.
  411      * @stable ICU 4.4
  412      */
  413      UnicodeString replaceFieldTypes(const UnicodeString& pattern,
  414                                      const UnicodeString& skeleton,
  415                                      UDateTimePatternMatchOptions options,
  416                                      UErrorCode& status);
  417 
  418     /**
  419      * Return a list of all the skeletons (in canonical form) from this class.
  420      *
  421      * Call getPatternForSkeleton() to get the corresponding pattern.
  422      *
  423      * @param status  Output param set to success/failure code on exit,
  424      *               which must not indicate a failure before the function call.
  425      * @return StringEnumeration with the skeletons.
  426      *         The caller must delete the object.
  427      * @stable ICU 3.8
  428      */
  429      StringEnumeration* getSkeletons(UErrorCode& status) const;
  430 
  431      /**
  432       * Get the pattern corresponding to a given skeleton.
  433       * @param skeleton
  434       * @return pattern corresponding to a given skeleton.
  435       * @stable ICU 3.8
  436       */
  437      const UnicodeString& getPatternForSkeleton(const UnicodeString& skeleton) const;
  438 
  439     /**
  440      * Return a list of all the base skeletons (in canonical form) from this class.
  441      *
  442      * @param status  Output param set to success/failure code on exit,
  443      *               which must not indicate a failure before the function call.
  444      * @return a StringEnumeration with the base skeletons.
  445      *         The caller must delete the object.
  446      * @stable ICU 3.8
  447      */
  448      StringEnumeration* getBaseSkeletons(UErrorCode& status) const;
  449 
  450 #ifndef U_HIDE_INTERNAL_API
  451      /**
  452       * Return a list of redundant patterns are those which if removed, make no
  453       * difference in the resulting getBestPattern values. This method returns a
  454       * list of them, to help check the consistency of the patterns used to build
  455       * this generator.
  456       *
  457       * @param status  Output param set to success/failure code on exit,
  458       *               which must not indicate a failure before the function call.
  459       * @return a StringEnumeration with the redundant pattern.
  460       *         The caller must delete the object.
  461       * @internal ICU 3.8
  462       */
  463      StringEnumeration* getRedundants(UErrorCode& status);
  464 #endif  /* U_HIDE_INTERNAL_API */
  465 
  466     /**
  467      * The decimal value is used in formatting fractions of seconds. If the
  468      * skeleton contains fractional seconds, then this is used with the
  469      * fractional seconds. For example, suppose that the input pattern is
  470      * "hhmmssSSSS", and the best matching pattern internally is "H:mm:ss", and
  471      * the decimal string is ",". Then the resulting pattern is modified to be
  472      * "H:mm:ss,SSSS"
  473      *
  474      * @param decimal
  475      * @stable ICU 3.8
  476      */
  477     void setDecimal(const UnicodeString& decimal);
  478 
  479     /**
  480      * Getter corresponding to setDecimal.
  481      * @return UnicodeString corresponding to the decimal point
  482      * @stable ICU 3.8
  483      */
  484     const UnicodeString& getDecimal() const;
  485 
  486 #if !UCONFIG_NO_FORMATTING
  487 
  488 #ifndef U_HIDE_DRAFT_API
  489     /**
  490      * Get the default hour cycle for a locale. Uses the locale that the
  491      * DateTimePatternGenerator was initially created with.
  492      * 
  493      * Cannot be used on an empty DateTimePatternGenerator instance.
  494      * 
  495      * @param status  Output param set to success/failure code on exit, which
  496      *                which must not indicate a failure before the function call.
  497      *                Set to U_UNSUPPORTED_ERROR if used on an empty instance.
  498      * @return the default hour cycle.
  499      * @draft ICU 67
  500      */
  501     UDateFormatHourCycle getDefaultHourCycle(UErrorCode& status) const;
  502 #endif  /* U_HIDE_DRAFT_API */
  503 
  504 #endif /* #if !UCONFIG_NO_FORMATTING */
  505     
  506     /**
  507      * ICU "poor man's RTTI", returns a UClassID for the actual class.
  508      *
  509      * @stable ICU 3.8
  510      */
  511     virtual UClassID getDynamicClassID() const;
  512 
  513     /**
  514      * ICU "poor man's RTTI", returns a UClassID for this class.
  515      *
  516      * @stable ICU 3.8
  517      */
  518     static UClassID U_EXPORT2 getStaticClassID(void);
  519 
  520 private:
  521     /**
  522      * Constructor.
  523      */
  524     DateTimePatternGenerator(UErrorCode & status);
  525 
  526     /**
  527      * Constructor.
  528      */
  529     DateTimePatternGenerator(const Locale& locale, UErrorCode & status);
  530 
  531     /**
  532      * Copy constructor.
  533      * @param other DateTimePatternGenerator to copy
  534      */
  535     DateTimePatternGenerator(const DateTimePatternGenerator& other);
  536 
  537     /**
  538      * Default assignment operator.
  539      * @param other DateTimePatternGenerator to copy
  540      */
  541     DateTimePatternGenerator& operator=(const DateTimePatternGenerator& other);
  542 
  543     // TODO(ticket:13619): re-enable when UDATPG_NARROW no longer in  draft mode.
  544     // static const int32_t UDATPG_WIDTH_COUNT = UDATPG_NARROW + 1;
  545 
  546     Locale pLocale;  // pattern locale
  547     FormatParser *fp;
  548     DateTimeMatcher* dtMatcher;
  549     DistanceInfo *distanceInfo;
  550     PatternMap *patternMap;
  551     UnicodeString appendItemFormats[UDATPG_FIELD_COUNT];
  552     // TODO(ticket:13619): [3] -> UDATPG_WIDTH_COUNT
  553     UnicodeString fieldDisplayNames[UDATPG_FIELD_COUNT][3];
  554     UnicodeString dateTimeFormat;
  555     UnicodeString decimal;
  556     DateTimeMatcher *skipMatcher;
  557     Hashtable *fAvailableFormatKeyHash;
  558     UnicodeString emptyString;
  559     char16_t fDefaultHourFormatChar;
  560 
  561     int32_t fAllowedHourFormats[7];  // Actually an array of AllowedHourFormat enum type, ending with UNKNOWN.
  562 
  563     // Internal error code used for recording/reporting errors that occur during methods that do not
  564     // have a UErrorCode parameter. For example: the Copy Constructor, or the ::clone() method.
  565     // When this is set to an error the object is in an invalid state.
  566     UErrorCode internalErrorCode;
  567 
  568     /* internal flags masks for adjustFieldTypes etc. */
  569     enum {
  570         kDTPGNoFlags = 0,
  571         kDTPGFixFractionalSeconds = 1,
  572         kDTPGSkeletonUsesCapJ = 2
  573         // with #13183, no longer need flags for b, B
  574     };
  575 
  576     void initData(const Locale &locale, UErrorCode &status);
  577     void addCanonicalItems(UErrorCode &status);
  578     void addICUPatterns(const Locale& locale, UErrorCode& status);
  579     void hackTimes(const UnicodeString& hackPattern, UErrorCode& status);
  580     void getCalendarTypeToUse(const Locale& locale, CharString& destination, UErrorCode& err);
  581     void consumeShortTimePattern(const UnicodeString& shortTimePattern, UErrorCode& status);
  582     void addCLDRData(const Locale& locale, UErrorCode& status);
  583     UDateTimePatternConflict addPatternWithSkeleton(const UnicodeString& pattern, const UnicodeString * skeletonToUse, UBool override, UnicodeString& conflictingPattern, UErrorCode& status);
  584     void initHashtable(UErrorCode& status);
  585     void setDateTimeFromCalendar(const Locale& locale, UErrorCode& status);
  586     void setDecimalSymbols(const Locale& locale, UErrorCode& status);
  587     UDateTimePatternField getAppendFormatNumber(const char* field) const;
  588     // Note for the next 3: UDateTimePGDisplayWidth is now stable ICU 61
  589     UDateTimePatternField getFieldAndWidthIndices(const char* key, UDateTimePGDisplayWidth* widthP) const;
  590     void setFieldDisplayName(UDateTimePatternField field, UDateTimePGDisplayWidth width, const UnicodeString& value);
  591     UnicodeString& getMutableFieldDisplayName(UDateTimePatternField field, UDateTimePGDisplayWidth width);
  592     void getAppendName(UDateTimePatternField field, UnicodeString& value);
  593     UnicodeString mapSkeletonMetacharacters(const UnicodeString& patternForm, int32_t* flags, UErrorCode& status);
  594     const UnicodeString* getBestRaw(DateTimeMatcher& source, int32_t includeMask, DistanceInfo* missingFields, UErrorCode& status, const PtnSkeleton** specifiedSkeletonPtr = 0);
  595     UnicodeString adjustFieldTypes(const UnicodeString& pattern, const PtnSkeleton* specifiedSkeleton, int32_t flags, UDateTimePatternMatchOptions options = UDATPG_MATCH_NO_OPTIONS);
  596     UnicodeString getBestAppending(int32_t missingFields, int32_t flags, UErrorCode& status, UDateTimePatternMatchOptions options = UDATPG_MATCH_NO_OPTIONS);
  597     int32_t getTopBitNumber(int32_t foundMask) const;
  598     void setAvailableFormat(const UnicodeString &key, UErrorCode& status);
  599     UBool isAvailableFormatSet(const UnicodeString &key) const;
  600     void copyHashtable(Hashtable *other, UErrorCode &status);
  601     UBool isCanonicalItem(const UnicodeString& item) const;
  602     static void U_CALLCONV loadAllowedHourFormatsData(UErrorCode &status);
  603     void getAllowedHourFormats(const Locale &locale, UErrorCode &status);
  604 
  605     struct AppendItemFormatsSink;
  606     struct AppendItemNamesSink;
  607     struct AvailableFormatsSink;
  608 } ;// end class DateTimePatternGenerator
  609 
  610 U_NAMESPACE_END
  611 
  612 #endif /* U_SHOW_CPLUSPLUS_API */
  613 
  614 #endif