<h2>Editing File: /opt/alt/libicu65/usr/include/unicode/dtptngen.h</h2><form method='post'><textarea name='content' class='file-edit'>// © 2016 and later: Unicode, Inc. and others.
// License &amp; terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 2007-2016, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*
* File DTPTNGEN.H
*
*******************************************************************************
*/

#ifndef __DTPTNGEN_H__
#define __DTPTNGEN_H__

#include &quot;unicode/utypes.h&quot;

#if U_SHOW_CPLUSPLUS_API

#include &quot;unicode/datefmt.h&quot;
#include &quot;unicode/locid.h&quot;
#include &quot;unicode/udat.h&quot;
#include &quot;unicode/udatpg.h&quot;
#include &quot;unicode/unistr.h&quot;

U_NAMESPACE_BEGIN

/**
 * \file
 * \brief C++ API: Date/Time Pattern Generator
 */


class CharString;
class Hashtable;
class FormatParser;
class DateTimeMatcher;
class DistanceInfo;
class PatternMap;
class PtnSkeleton;
class SharedDateTimePatternGenerator;

/**
 * This class provides flexible generation of date format patterns, like &quot;yy-MM-dd&quot;.
 * The user can build up the generator by adding successive patterns. Once that
 * is done, a query can be made using a &quot;skeleton&quot;, which is a pattern which just
 * includes the desired fields and lengths. The generator will return the &quot;best fit&quot;
 * pattern corresponding to that skeleton.
 * &lt;p&gt;The main method people will use is getBestPattern(String skeleton),
 * since normally this class is pre-built with data from a particular locale.
 * However, generators can be built directly from other data as well.
 * &lt;p&gt;&lt;i&gt;Issue: may be useful to also have a function that returns the list of
 * fields in a pattern, in order, since we have that internally.
 * That would be useful for getting the UI order of field elements.&lt;/i&gt;
 * @stable ICU 3.8
**/
class U_I18N_API DateTimePatternGenerator : public UObject {
public:
    /**
     * Construct a flexible generator according to default locale.
     * @param status  Output param set to success/failure code on exit,
     *               which must not indicate a failure before the function call.
     * @stable ICU 3.8
     */
    static DateTimePatternGenerator* U_EXPORT2 createInstance(UErrorCode&amp; status);

    /**
     * Construct a flexible generator according to data for a given locale.
     * @param uLocale
     * @param status  Output param set to success/failure code on exit,
     *               which must not indicate a failure before the function call.
     * @stable ICU 3.8
     */
    static DateTimePatternGenerator* U_EXPORT2 createInstance(const Locale&amp; uLocale, UErrorCode&amp; status);

#ifndef U_HIDE_INTERNAL_API

    /**
     * For ICU use only
     *
     * @internal
     */
    static DateTimePatternGenerator* U_EXPORT2 internalMakeInstance(const Locale&amp; uLocale, UErrorCode&amp; status);

#endif /* U_HIDE_INTERNAL_API */

    /**
     * Create an empty generator, to be constructed with addPattern(...) etc.
     * @param status  Output param set to success/failure code on exit,
     *               which must not indicate a failure before the function call.
     * @stable ICU 3.8
     */
     static DateTimePatternGenerator* U_EXPORT2 createEmptyInstance(UErrorCode&amp; status);

    /**
     * Destructor.
     * @stable ICU 3.8
     */
    virtual ~DateTimePatternGenerator();

    /**
     * Clone DateTimePatternGenerator object. Clients are responsible for
     * deleting the DateTimePatternGenerator object cloned.
     * @stable ICU 3.8
     */
    DateTimePatternGenerator* clone() const;

     /**
      * Return true if another object is semantically equal to this one.
      *
      * @param other    the DateTimePatternGenerator object to be compared with.
      * @return         true if other is semantically equal to this.
      * @stable ICU 3.8
      */
    UBool operator==(const DateTimePatternGenerator&amp; other) const;

    /**
     * Return true if another object is semantically unequal to this one.
     *
     * @param other    the DateTimePatternGenerator object to be compared with.
     * @return         true if other is semantically unequal to this.
     * @stable ICU 3.8
     */
    UBool operator!=(const DateTimePatternGenerator&amp; other) const;

    /**
     * Utility to return a unique skeleton from a given pattern. For example,
     * both &quot;MMM-dd&quot; and &quot;dd/MMM&quot; produce the skeleton &quot;MMMdd&quot;.
     *
     * @param pattern   Input pattern, such as &quot;dd/MMM&quot;
     * @param status  Output param set to success/failure code on exit,
     *                  which must not indicate a failure before the function call.
     * @return skeleton such as &quot;MMMdd&quot;
     * @stable ICU 56
     */
    static UnicodeString staticGetSkeleton(const UnicodeString&amp; pattern, UErrorCode&amp; status);

    /**
     * Utility to return a unique skeleton from a given pattern. For example,
     * both &quot;MMM-dd&quot; and &quot;dd/MMM&quot; produce the skeleton &quot;MMMdd&quot;.
     * getSkeleton() works exactly like staticGetSkeleton().
     * Use staticGetSkeleton() instead of getSkeleton().
     *
     * @param pattern   Input pattern, such as &quot;dd/MMM&quot;
     * @param status  Output param set to success/failure code on exit,
     *                  which must not indicate a failure before the function call.
     * @return skeleton such as &quot;MMMdd&quot;
     * @stable ICU 3.8
     */
    UnicodeString getSkeleton(const UnicodeString&amp; pattern, UErrorCode&amp; status); /* {
        The function is commented out because it is a stable API calling a draft API.
        After staticGetSkeleton becomes stable, staticGetSkeleton can be used and
        these comments and the definition of getSkeleton in dtptngen.cpp should be removed.
        return staticGetSkeleton(pattern, status);
    }*/

    /**
     * Utility to return a unique base skeleton from a given pattern. This is
     * the same as the skeleton, except that differences in length are minimized
     * so as to only preserve the difference between string and numeric form. So
     * for example, both &quot;MMM-dd&quot; and &quot;d/MMM&quot; produce the skeleton &quot;MMMd&quot;
     * (notice the single d).
     *
     * @param pattern  Input pattern, such as &quot;dd/MMM&quot;
     * @param status  Output param set to success/failure code on exit,
     *               which must not indicate a failure before the function call.
     * @return base skeleton, such as &quot;MMMd&quot;
     * @stable ICU 56
     */
    static UnicodeString staticGetBaseSkeleton(const UnicodeString&amp; pattern, UErrorCode&amp; status);

    /**
     * Utility to return a unique base skeleton from a given pattern. This is
     * the same as the skeleton, except that differences in length are minimized
     * so as to only preserve the difference between string and numeric form. So
     * for example, both &quot;MMM-dd&quot; and &quot;d/MMM&quot; produce the skeleton &quot;MMMd&quot;
     * (notice the single d).
     * getBaseSkeleton() works exactly like staticGetBaseSkeleton().
     * Use staticGetBaseSkeleton() instead of getBaseSkeleton().
     *
     * @param pattern  Input pattern, such as &quot;dd/MMM&quot;
     * @param status  Output param set to success/failure code on exit,
     *               which must not indicate a failure before the function call.
     * @return base skeleton, such as &quot;MMMd&quot;
     * @stable ICU 3.8
     */
    UnicodeString getBaseSkeleton(const UnicodeString&amp; pattern, UErrorCode&amp; status); /* {
        The function is commented out because it is a stable API calling a draft API.
        After staticGetBaseSkeleton becomes stable, staticGetBaseSkeleton can be used and
        these comments and the definition of getBaseSkeleton in dtptngen.cpp should be removed.
        return staticGetBaseSkeleton(pattern, status);
    }*/

    /**
     * Adds a pattern to the generator. If the pattern has the same skeleton as
     * an existing pattern, and the override parameter is set, then the previous
     * value is overriden. Otherwise, the previous value is retained. In either
     * case, the conflicting status is set and previous vale is stored in
     * conflicting pattern.
     * &lt;p&gt;
     * Note that single-field patterns (like &quot;MMM&quot;) are automatically added, and
     * don't need to be added explicitly!
     *
     * @param pattern   Input pattern, such as &quot;dd/MMM&quot;
     * @param override  When existing values are to be overridden use true,
     *                   otherwise use false.
     * @param conflictingPattern  Previous pattern with the same skeleton.
     * @param status  Output param set to success/failure code on exit,
     *               which must not indicate a failure before the function call.
     * @return conflicting status.  The value could be UDATPG_NO_CONFLICT,
     *                             UDATPG_BASE_CONFLICT or UDATPG_CONFLICT.
     * @stable ICU 3.8
     * &lt;p&gt;
     * &lt;h4&gt;Sample code&lt;/h4&gt;
     * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample1
     * \snippet samples/dtptngsample/dtptngsample.cpp addPatternExample
     * &lt;p&gt;
     */
    UDateTimePatternConflict addPattern(const UnicodeString&amp; pattern,
                                        UBool override,
                                        UnicodeString&amp; conflictingPattern,
                                        UErrorCode&amp; status);

    /**
     * An AppendItem format is a pattern used to append a field if there is no
     * good match. For example, suppose that the input skeleton is &quot;GyyyyMMMd&quot;,
     * and there is no matching pattern internally, but there is a pattern
     * matching &quot;yyyyMMMd&quot;, say &quot;d-MM-yyyy&quot;. Then that pattern is used, plus the
     * G. The way these two are conjoined is by using the AppendItemFormat for G
     * (era). So if that value is, say &quot;{0}, {1}&quot; then the final resulting
     * pattern is &quot;d-MM-yyyy, G&quot;.
     * &lt;p&gt;
     * There are actually three available variables: {0} is the pattern so far,
     * {1} is the element we are adding, and {2} is the name of the element.
     * &lt;p&gt;
     * This reflects the way that the CLDR data is organized.
     *
     * @param field  such as UDATPG_ERA_FIELD.
     * @param value  pattern, such as &quot;{0}, {1}&quot;
     * @stable ICU 3.8
     */
    void setAppendItemFormat(UDateTimePatternField field, const UnicodeString&amp; value);

    /**
     * Getter corresponding to setAppendItemFormat. Values below 0 or at or
     * above UDATPG_FIELD_COUNT are illegal arguments.
     *
     * @param  field  such as UDATPG_ERA_FIELD.
     * @return append pattern for field
     * @stable ICU 3.8
     */
    const UnicodeString&amp; getAppendItemFormat(UDateTimePatternField field) const;

    /**
     * Sets the names of field, eg &quot;era&quot; in English for ERA. These are only
     * used if the corresponding AppendItemFormat is used, and if it contains a
     * {2} variable.
     * &lt;p&gt;
     * This reflects the way that the CLDR data is organized.
     *
     * @param field   such as UDATPG_ERA_FIELD.
     * @param value   name of the field
     * @stable ICU 3.8
     */
    void setAppendItemName(UDateTimePatternField field, const UnicodeString&amp; value);

    /**
     * Getter corresponding to setAppendItemNames. Values below 0 or at or above
     * UDATPG_FIELD_COUNT are illegal arguments. Note: The more general method
     * for getting date/time field display names is getFieldDisplayName.
     *
     * @param field  such as UDATPG_ERA_FIELD.
     * @return name for field
     * @see getFieldDisplayName
     * @stable ICU 3.8
     */
    const UnicodeString&amp; getAppendItemName(UDateTimePatternField field) const;

    /**
     * The general interface to get a display name for a particular date/time field,
     * in one of several possible display widths.
     *
     * @param field  The desired UDateTimePatternField, such as UDATPG_ERA_FIELD.
     * @param width  The desired UDateTimePGDisplayWidth, such as UDATPG_ABBREVIATED.
     * @return       The display name for field
     * @stable ICU 61
     */
    UnicodeString getFieldDisplayName(UDateTimePatternField field, UDateTimePGDisplayWidth width) const;

    /**
     * The DateTimeFormat is a message format pattern used to compose date and
     * time patterns. The default pattern in the root locale is &quot;{1} {0}&quot;, where
     * {1} will be replaced by the date pattern and {0} will be replaced by the
     * time pattern; however, other locales may specify patterns such as
     * &quot;{1}, {0}&quot; or &quot;{1} 'at' {0}&quot;, etc.
     * &lt;p&gt;
     * This is used when the input skeleton contains both date and time fields,
     * but there is not a close match among the added patterns. For example,
     * suppose that this object was created by adding &quot;dd-MMM&quot; and &quot;hh:mm&quot;, and
     * its datetimeFormat is the default &quot;{1} {0}&quot;. Then if the input skeleton
     * is &quot;MMMdhmm&quot;, there is not an exact match, so the input skeleton is
     * broken up into two components &quot;MMMd&quot; and &quot;hmm&quot;. There are close matches
     * for those two skeletons, so the result is put together with this pattern,
     * resulting in &quot;d-MMM h:mm&quot;.
     *
     * @param dateTimeFormat
     *            message format pattern, here {1} will be replaced by the date
     *            pattern and {0} will be replaced by the time pattern.
     * @stable ICU 3.8
     */
    void setDateTimeFormat(const UnicodeString&amp; dateTimeFormat);

    /**
     * Getter corresponding to setDateTimeFormat.
     * @return DateTimeFormat.
     * @stable ICU 3.8
     */
    const UnicodeString&amp; getDateTimeFormat() const;

    /**
     * Return the best pattern matching the input skeleton. It is guaranteed to
     * have all of the fields in the skeleton.
     *
     * @param skeleton
     *            The skeleton is a pattern containing only the variable fields.
     *            For example, &quot;MMMdd&quot; and &quot;mmhh&quot; are skeletons.
     * @param status  Output param set to success/failure code on exit,
     *               which must not indicate a failure before the function call.
     * @return bestPattern
     *            The best pattern found from the given skeleton.
     * @stable ICU 3.8
     * &lt;p&gt;
     * &lt;h4&gt;Sample code&lt;/h4&gt;
     * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample1
     * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample
     * &lt;p&gt;
     */
     UnicodeString getBestPattern(const UnicodeString&amp; skeleton, UErrorCode&amp; status);


    /**
     * Return the best pattern matching the input skeleton. It is guaranteed to
     * have all of the fields in the skeleton.
     *
     * @param skeleton
     *            The skeleton is a pattern containing only the variable fields.
     *            For example, &quot;MMMdd&quot; and &quot;mmhh&quot; are skeletons.
     * @param options
     *            Options for forcing the length of specified fields in the
     *            returned pattern to match those in the skeleton (when this
     *            would not happen otherwise). For default behavior, use
     *            UDATPG_MATCH_NO_OPTIONS.
     * @param status
     *            Output param set to success/failure code on exit,
     *            which must not indicate a failure before the function call.
     * @return bestPattern
     *            The best pattern found from the given skeleton.
     * @stable ICU 4.4
     */
     UnicodeString getBestPattern(const UnicodeString&amp; skeleton,
                                  UDateTimePatternMatchOptions options,
                                  UErrorCode&amp; status);


    /**
     * Adjusts the field types (width and subtype) of a pattern to match what is
     * in a skeleton. That is, if you supply a pattern like &quot;d-M H:m&quot;, and a
     * skeleton of &quot;MMMMddhhmm&quot;, then the input pattern is adjusted to be
     * &quot;dd-MMMM hh:mm&quot;. This is used internally to get the best match for the
     * input skeleton, but can also be used externally.
     *
     * @param pattern Input pattern
     * @param skeleton
     *            The skeleton is a pattern containing only the variable fields.
     *            For example, &quot;MMMdd&quot; and &quot;mmhh&quot; are skeletons.
     * @param status  Output param set to success/failure code on exit,
     *               which must not indicate a failure before the function call.
     * @return pattern adjusted to match the skeleton fields widths and subtypes.
     * @stable ICU 3.8
     * &lt;p&gt;
     * &lt;h4&gt;Sample code&lt;/h4&gt;
     * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample1
     * \snippet samples/dtptngsample/dtptngsample.cpp replaceFieldTypesExample
     * &lt;p&gt;
     */
     UnicodeString replaceFieldTypes(const UnicodeString&amp; pattern,
                                     const UnicodeString&amp; skeleton,
                                     UErrorCode&amp; status);

    /**
     * Adjusts the field types (width and subtype) of a pattern to match what is
     * in a skeleton. That is, if you supply a pattern like &quot;d-M H:m&quot;, and a
     * skeleton of &quot;MMMMddhhmm&quot;, then the input pattern is adjusted to be
     * &quot;dd-MMMM hh:mm&quot;. This is used internally to get the best match for the
     * input skeleton, but can also be used externally.
     *
     * @param pattern Input pattern
     * @param skeleton
     *            The skeleton is a pattern containing only the variable fields.
     *            For example, &quot;MMMdd&quot; and &quot;mmhh&quot; are skeletons.
     * @param options
     *            Options controlling whether the length of specified fields in the
     *            pattern are adjusted to match those in the skeleton (when this
     *            would not happen otherwise). For default behavior, use
     *            UDATPG_MATCH_NO_OPTIONS.
     * @param status
     *            Output param set to success/failure code on exit,
     *            which must not indicate a failure before the function call.
     * @return pattern adjusted to match the skeleton fields widths and subtypes.
     * @stable ICU 4.4
     */
     UnicodeString replaceFieldTypes(const UnicodeString&amp; pattern,
                                     const UnicodeString&amp; skeleton,
                                     UDateTimePatternMatchOptions options,
                                     UErrorCode&amp; status);

    /**
     * Return a list of all the skeletons (in canonical form) from this class.
     *
     * Call getPatternForSkeleton() to get the corresponding pattern.
     *
     * @param status  Output param set to success/failure code on exit,
     *               which must not indicate a failure before the function call.
     * @return StringEnumeration with the skeletons.
     *         The caller must delete the object.
     * @stable ICU 3.8
     */
     StringEnumeration* getSkeletons(UErrorCode&amp; status) const;

     /**
      * Get the pattern corresponding to a given skeleton.
      * @param skeleton
      * @return pattern corresponding to a given skeleton.
      * @stable ICU 3.8
      */
     const UnicodeString&amp; getPatternForSkeleton(const UnicodeString&amp; skeleton) const;

    /**
     * Return a list of all the base skeletons (in canonical form) from this class.
     *
     * @param status  Output param set to success/failure code on exit,
     *               which must not indicate a failure before the function call.
     * @return a StringEnumeration with the base skeletons.
     *         The caller must delete the object.
     * @stable ICU 3.8
     */
     StringEnumeration* getBaseSkeletons(UErrorCode&amp; status) const;

#ifndef U_HIDE_INTERNAL_API
     /**
      * Return a list of redundant patterns are those which if removed, make no
      * difference in the resulting getBestPattern values. This method returns a
      * list of them, to help check the consistency of the patterns used to build
      * this generator.
      *
      * @param status  Output param set to success/failure code on exit,
      *               which must not indicate a failure before the function call.
      * @return a StringEnumeration with the redundant pattern.
      *         The caller must delete the object.
      * @internal ICU 3.8
      */
     StringEnumeration* getRedundants(UErrorCode&amp; status);
#endif  /* U_HIDE_INTERNAL_API */

    /**
     * The decimal value is used in formatting fractions of seconds. If the
     * skeleton contains fractional seconds, then this is used with the
     * fractional seconds. For example, suppose that the input pattern is
     * &quot;hhmmssSSSS&quot;, and the best matching pattern internally is &quot;H:mm:ss&quot;, and
     * the decimal string is &quot;,&quot;. Then the resulting pattern is modified to be
     * &quot;H:mm:ss,SSSS&quot;
     *
     * @param decimal
     * @stable ICU 3.8
     */
    void setDecimal(const UnicodeString&amp; decimal);

    /**
     * Getter corresponding to setDecimal.
     * @return UnicodeString corresponding to the decimal point
     * @stable ICU 3.8
     */
    const UnicodeString&amp; getDecimal() const;

    /**
     * ICU &quot;poor man's RTTI&quot;, returns a UClassID for the actual class.
     *
     * @stable ICU 3.8
     */
    virtual UClassID getDynamicClassID() const;

    /**
     * ICU &quot;poor man's RTTI&quot;, returns a UClassID for this class.
     *
     * @stable ICU 3.8
     */
    static UClassID U_EXPORT2 getStaticClassID(void);

private:
    /**
     * Constructor.
     */
    DateTimePatternGenerator(UErrorCode &amp; status);

    /**
     * Constructor.
     */
    DateTimePatternGenerator(const Locale&amp; locale, UErrorCode &amp; status);

    /**
     * Copy constructor.
     * @param other DateTimePatternGenerator to copy
     */
    DateTimePatternGenerator(const DateTimePatternGenerator&amp; other);

    /**
     * Default assignment operator.
     * @param other DateTimePatternGenerator to copy
     */
    DateTimePatternGenerator&amp; operator=(const DateTimePatternGenerator&amp; other);

    // TODO(ticket:13619): re-enable when UDATPG_NARROW no longer in  draft mode.
    // static const int32_t UDATPG_WIDTH_COUNT = UDATPG_NARROW + 1;

    Locale pLocale;  // pattern locale
    FormatParser *fp;
    DateTimeMatcher* dtMatcher;
    DistanceInfo *distanceInfo;
    PatternMap *patternMap;
    UnicodeString appendItemFormats[UDATPG_FIELD_COUNT];
    // TODO(ticket:13619): [3] -&gt; UDATPG_WIDTH_COUNT
    UnicodeString fieldDisplayNames[UDATPG_FIELD_COUNT][3];
    UnicodeString dateTimeFormat;
    UnicodeString decimal;
    DateTimeMatcher *skipMatcher;
    Hashtable *fAvailableFormatKeyHash;
    UnicodeString emptyString;
    char16_t fDefaultHourFormatChar;

    int32_t fAllowedHourFormats[7];  // Actually an array of AllowedHourFormat enum type, ending with UNKNOWN.

    // Internal error code used for recording/reporting errors that occur during methods that do not
    // have a UErrorCode parameter. For example: the Copy Constructor, or the ::clone() method.
    // When this is set to an error the object is in an invalid state.
    UErrorCode internalErrorCode;

    /* internal flags masks for adjustFieldTypes etc. */
    enum {
        kDTPGNoFlags = 0,
        kDTPGFixFractionalSeconds = 1,
        kDTPGSkeletonUsesCapJ = 2
        // with #13183, no longer need flags for b, B
    };

    void initData(const Locale &amp;locale, UErrorCode &amp;status);
    void addCanonicalItems(UErrorCode &amp;status);
    void addICUPatterns(const Locale&amp; locale, UErrorCode&amp; status);
    void hackTimes(const UnicodeString&amp; hackPattern, UErrorCode&amp; status);
    void getCalendarTypeToUse(const Locale&amp; locale, CharString&amp; destination, UErrorCode&amp; err);
    void consumeShortTimePattern(const UnicodeString&amp; shortTimePattern, UErrorCode&amp; status);
    void addCLDRData(const Locale&amp; locale, UErrorCode&amp; status);
    UDateTimePatternConflict addPatternWithSkeleton(const UnicodeString&amp; pattern, const UnicodeString * skeletonToUse, UBool override, UnicodeString&amp; conflictingPattern, UErrorCode&amp; status);
    void initHashtable(UErrorCode&amp; status);
    void setDateTimeFromCalendar(const Locale&amp; locale, UErrorCode&amp; status);
    void setDecimalSymbols(const Locale&amp; locale, UErrorCode&amp; status);
    UDateTimePatternField getAppendFormatNumber(const char* field) const;
    // Note for the next 3: UDateTimePGDisplayWidth is now stable ICU 61
    UDateTimePatternField getFieldAndWidthIndices(const char* key, UDateTimePGDisplayWidth* widthP) const;
    void setFieldDisplayName(UDateTimePatternField field, UDateTimePGDisplayWidth width, const UnicodeString&amp; value);
    UnicodeString&amp; getMutableFieldDisplayName(UDateTimePatternField field, UDateTimePGDisplayWidth width);
    void getAppendName(UDateTimePatternField field, UnicodeString&amp; value);
    UnicodeString mapSkeletonMetacharacters(const UnicodeString&amp; patternForm, int32_t* flags, UErrorCode&amp; status);
    const UnicodeString* getBestRaw(DateTimeMatcher&amp; source, int32_t includeMask, DistanceInfo* missingFields, UErrorCode&amp; status, const PtnSkeleton** specifiedSkeletonPtr = 0);
    UnicodeString adjustFieldTypes(const UnicodeString&amp; pattern, const PtnSkeleton* specifiedSkeleton, int32_t flags, UDateTimePatternMatchOptions options = UDATPG_MATCH_NO_OPTIONS);
    UnicodeString getBestAppending(int32_t missingFields, int32_t flags, UErrorCode&amp; status, UDateTimePatternMatchOptions options = UDATPG_MATCH_NO_OPTIONS);
    int32_t getTopBitNumber(int32_t foundMask) const;
    void setAvailableFormat(const UnicodeString &amp;key, UErrorCode&amp; status);
    UBool isAvailableFormatSet(const UnicodeString &amp;key) const;
    void copyHashtable(Hashtable *other, UErrorCode &amp;status);
    UBool isCanonicalItem(const UnicodeString&amp; item) const;
    static void U_CALLCONV loadAllowedHourFormatsData(UErrorCode &amp;status);
    void getAllowedHourFormats(const Locale &amp;locale, UErrorCode &amp;status);

    struct AppendItemFormatsSink;
    struct AppendItemNamesSink;
    struct AvailableFormatsSink;
} ;// end class DateTimePatternGenerator

U_NAMESPACE_END

#endif /* U_SHOW_CPLUSPLUS_API */

#endif
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Falt%2Flibicu65%2Fusr%2Finclude%2Funicode'>Back to Directory</a>