Home | History | Annotate | Download | only in unicode
      1 /*
      2 *******************************************************************************
      3 *
      4 *   Copyright (C) 2007-2012, International Business Machines
      5 *   Corporation and others.  All Rights Reserved.
      6 *
      7 *******************************************************************************
      8 *   file name:  udatpg.h
      9 *   encoding:   US-ASCII
     10 *   tab size:   8 (not used)
     11 *   indentation:4
     12 *
     13 *   created on: 2007jul30
     14 *   created by: Markus W. Scherer
     15 */
     16 
     17 #ifndef __UDATPG_H__
     18 #define __UDATPG_H__
     19 
     20 #include "unicode/utypes.h"
     21 #include "unicode/uenum.h"
     22 #include "unicode/localpointer.h"
     23 
     24 /**
     25  * \file
     26  * \brief C API: Wrapper for icu::DateTimePatternGenerator (unicode/dtptngen.h).
     27  *
     28  * UDateTimePatternGenerator provides flexible generation of date format patterns,
     29  * like "yy-MM-dd". The user can build up the generator by adding successive
     30  * patterns. Once that is done, a query can be made using a "skeleton", which is
     31  * a pattern which just includes the desired fields and lengths. The generator
     32  * will return the "best fit" pattern corresponding to that skeleton.
     33  * <p>The main method people will use is udatpg_getBestPattern, since normally
     34  * UDateTimePatternGenerator is pre-built with data from a particular locale.
     35  * However, generators can be built directly from other data as well.
     36  * <p><i>Issue: may be useful to also have a function that returns the list of
     37  * fields in a pattern, in order, since we have that internally.
     38  * That would be useful for getting the UI order of field elements.</i>
     39  */
     40 
     41 /**
     42  * Opaque type for a date/time pattern generator object.
     43  * @stable ICU 3.8
     44  */
     45 typedef void *UDateTimePatternGenerator;
     46 
     47 /**
     48  * Field number constants for udatpg_getAppendItemFormats() and similar functions.
     49  * These constants are separate from UDateFormatField despite semantic overlap
     50  * because some fields are merged for the date/time pattern generator.
     51  * @stable ICU 3.8
     52  */
     53 typedef enum UDateTimePatternField {
     54     /** @stable ICU 3.8 */
     55     UDATPG_ERA_FIELD,
     56     /** @stable ICU 3.8 */
     57     UDATPG_YEAR_FIELD,
     58     /** @stable ICU 3.8 */
     59     UDATPG_QUARTER_FIELD,
     60     /** @stable ICU 3.8 */
     61     UDATPG_MONTH_FIELD,
     62     /** @stable ICU 3.8 */
     63     UDATPG_WEEK_OF_YEAR_FIELD,
     64     /** @stable ICU 3.8 */
     65     UDATPG_WEEK_OF_MONTH_FIELD,
     66     /** @stable ICU 3.8 */
     67     UDATPG_WEEKDAY_FIELD,
     68     /** @stable ICU 3.8 */
     69     UDATPG_DAY_OF_YEAR_FIELD,
     70     /** @stable ICU 3.8 */
     71     UDATPG_DAY_OF_WEEK_IN_MONTH_FIELD,
     72     /** @stable ICU 3.8 */
     73     UDATPG_DAY_FIELD,
     74     /** @stable ICU 3.8 */
     75     UDATPG_DAYPERIOD_FIELD,
     76     /** @stable ICU 3.8 */
     77     UDATPG_HOUR_FIELD,
     78     /** @stable ICU 3.8 */
     79     UDATPG_MINUTE_FIELD,
     80     /** @stable ICU 3.8 */
     81     UDATPG_SECOND_FIELD,
     82     /** @stable ICU 3.8 */
     83     UDATPG_FRACTIONAL_SECOND_FIELD,
     84     /** @stable ICU 3.8 */
     85     UDATPG_ZONE_FIELD,
     86     /** @stable ICU 3.8 */
     87     UDATPG_FIELD_COUNT
     88 } UDateTimePatternField;
     89 
     90 /**
     91  * Masks to control forcing the length of specified fields in the returned
     92  * pattern to match those in the skeleton (when this would not happen
     93  * otherwise). These may be combined to force the length of multiple fields.
     94  * Used with udatpg_getBestPatternWithOptions, udatpg_replaceFieldTypesWithOptions.
     95  * @stable ICU 4.4
     96  */
     97 typedef enum UDateTimePatternMatchOptions {
     98     /** @stable ICU 4.4 */
     99     UDATPG_MATCH_NO_OPTIONS = 0,
    100     /** @stable ICU 4.4 */
    101     UDATPG_MATCH_HOUR_FIELD_LENGTH = 1 << UDATPG_HOUR_FIELD,
    102 #ifndef U_HIDE_INTERNAL_API
    103     /** @internal ICU 4.4 */
    104     UDATPG_MATCH_MINUTE_FIELD_LENGTH = 1 << UDATPG_MINUTE_FIELD,
    105     /** @internal ICU 4.4 */
    106     UDATPG_MATCH_SECOND_FIELD_LENGTH = 1 << UDATPG_SECOND_FIELD,
    107 #endif  /* U_HIDE_INTERNAL_API */
    108     /** @stable ICU 4.4 */
    109     UDATPG_MATCH_ALL_FIELDS_LENGTH = (1 << UDATPG_FIELD_COUNT) - 1
    110 } UDateTimePatternMatchOptions;
    111 
    112 /**
    113  * Status return values from udatpg_addPattern().
    114  * @stable ICU 3.8
    115  */
    116 typedef enum UDateTimePatternConflict {
    117     /** @stable ICU 3.8 */
    118     UDATPG_NO_CONFLICT,
    119     /** @stable ICU 3.8 */
    120     UDATPG_BASE_CONFLICT,
    121     /** @stable ICU 3.8 */
    122     UDATPG_CONFLICT,
    123     /** @stable ICU 3.8 */
    124     UDATPG_CONFLICT_COUNT
    125 } UDateTimePatternConflict;
    126 
    127 /**
    128   * Open a generator according to a given locale.
    129   * @param locale
    130   * @param pErrorCode a pointer to the UErrorCode which must not indicate a
    131   *                   failure before the function call.
    132   * @return a pointer to UDateTimePatternGenerator.
    133   * @stable ICU 3.8
    134   */
    135 U_STABLE UDateTimePatternGenerator * U_EXPORT2
    136 udatpg_open(const char *locale, UErrorCode *pErrorCode);
    137 
    138 /**
    139   * Open an empty generator, to be constructed with udatpg_addPattern(...) etc.
    140   * @param pErrorCode a pointer to the UErrorCode which must not indicate a
    141   *                   failure before the function call.
    142   * @return a pointer to UDateTimePatternGenerator.
    143   * @stable ICU 3.8
    144   */
    145 U_STABLE UDateTimePatternGenerator * U_EXPORT2
    146 udatpg_openEmpty(UErrorCode *pErrorCode);
    147 
    148 /**
    149   * Close a generator.
    150   * @param dtpg a pointer to UDateTimePatternGenerator.
    151   * @stable ICU 3.8
    152   */
    153 U_STABLE void U_EXPORT2
    154 udatpg_close(UDateTimePatternGenerator *dtpg);
    155 
    156 #if U_SHOW_CPLUSPLUS_API
    157 
    158 U_NAMESPACE_BEGIN
    159 
    160 /**
    161  * \class LocalUDateTimePatternGeneratorPointer
    162  * "Smart pointer" class, closes a UDateTimePatternGenerator via udatpg_close().
    163  * For most methods see the LocalPointerBase base class.
    164  *
    165  * @see LocalPointerBase
    166  * @see LocalPointer
    167  * @stable ICU 4.4
    168  */
    169 U_DEFINE_LOCAL_OPEN_POINTER(LocalUDateTimePatternGeneratorPointer, UDateTimePatternGenerator, udatpg_close);
    170 
    171 U_NAMESPACE_END
    172 
    173 #endif
    174 
    175 /**
    176   * Create a copy pf a generator.
    177   * @param dtpg a pointer to UDateTimePatternGenerator to be copied.
    178   * @param pErrorCode a pointer to the UErrorCode which must not indicate a
    179   *                   failure before the function call.
    180   * @return a pointer to a new UDateTimePatternGenerator.
    181   * @stable ICU 3.8
    182  */
    183 U_STABLE UDateTimePatternGenerator * U_EXPORT2
    184 udatpg_clone(const UDateTimePatternGenerator *dtpg, UErrorCode *pErrorCode);
    185 
    186 /**
    187  * Get the best pattern matching the input skeleton. It is guaranteed to
    188  * have all of the fields in the skeleton.
    189  *
    190  * Note that this function uses a non-const UDateTimePatternGenerator:
    191  * It uses a stateful pattern parser which is set up for each generator object,
    192  * rather than creating one for each function call.
    193  * Consecutive calls to this function do not affect each other,
    194  * but this function cannot be used concurrently on a single generator object.
    195  *
    196  * @param dtpg a pointer to UDateTimePatternGenerator.
    197  * @param skeleton
    198  *            The skeleton is a pattern containing only the variable fields.
    199  *            For example, "MMMdd" and "mmhh" are skeletons.
    200  * @param length the length of skeleton
    201  * @param bestPattern
    202  *            The best pattern found from the given skeleton.
    203  * @param capacity the capacity of bestPattern.
    204  * @param pErrorCode a pointer to the UErrorCode which must not indicate a
    205  *                   failure before the function call.
    206  * @return the length of bestPattern.
    207  * @stable ICU 3.8
    208  */
    209 U_STABLE int32_t U_EXPORT2
    210 udatpg_getBestPattern(UDateTimePatternGenerator *dtpg,
    211                       const UChar *skeleton, int32_t length,
    212                       UChar *bestPattern, int32_t capacity,
    213                       UErrorCode *pErrorCode);
    214 
    215 /**
    216  * Get the best pattern matching the input skeleton. It is guaranteed to
    217  * have all of the fields in the skeleton.
    218  *
    219  * Note that this function uses a non-const UDateTimePatternGenerator:
    220  * It uses a stateful pattern parser which is set up for each generator object,
    221  * rather than creating one for each function call.
    222  * Consecutive calls to this function do not affect each other,
    223  * but this function cannot be used concurrently on a single generator object.
    224  *
    225  * @param dtpg a pointer to UDateTimePatternGenerator.
    226  * @param skeleton
    227  *            The skeleton is a pattern containing only the variable fields.
    228  *            For example, "MMMdd" and "mmhh" are skeletons.
    229  * @param length the length of skeleton
    230  * @param options
    231  *            Options for forcing the length of specified fields in the
    232  *            returned pattern to match those in the skeleton (when this
    233  *            would not happen otherwise). For default behavior, use
    234  *            UDATPG_MATCH_NO_OPTIONS.
    235  * @param bestPattern
    236  *            The best pattern found from the given skeleton.
    237  * @param capacity
    238  *            the capacity of bestPattern.
    239  * @param pErrorCode
    240  *            a pointer to the UErrorCode which must not indicate a
    241  *            failure before the function call.
    242  * @return the length of bestPattern.
    243  * @stable ICU 4.4
    244  */
    245 U_STABLE int32_t U_EXPORT2
    246 udatpg_getBestPatternWithOptions(UDateTimePatternGenerator *dtpg,
    247                                  const UChar *skeleton, int32_t length,
    248                                  UDateTimePatternMatchOptions options,
    249                                  UChar *bestPattern, int32_t capacity,
    250                                  UErrorCode *pErrorCode);
    251 
    252 /**
    253   * Get a unique skeleton from a given pattern. For example,
    254   * both "MMM-dd" and "dd/MMM" produce the skeleton "MMMdd".
    255   *
    256   * Note that this function uses a non-const UDateTimePatternGenerator:
    257   * It uses a stateful pattern parser which is set up for each generator object,
    258   * rather than creating one for each function call.
    259   * Consecutive calls to this function do not affect each other,
    260   * but this function cannot be used concurrently on a single generator object.
    261   *
    262   * @param dtpg     a pointer to UDateTimePatternGenerator.
    263   * @param pattern  input pattern, such as "dd/MMM".
    264   * @param length   the length of pattern.
    265   * @param skeleton such as "MMMdd"
    266   * @param capacity the capacity of skeleton.
    267   * @param pErrorCode a pointer to the UErrorCode which must not indicate a
    268   *                  failure before the function call.
    269   * @return the length of skeleton.
    270   * @stable ICU 3.8
    271   */
    272 U_STABLE int32_t U_EXPORT2
    273 udatpg_getSkeleton(UDateTimePatternGenerator *dtpg,
    274                    const UChar *pattern, int32_t length,
    275                    UChar *skeleton, int32_t capacity,
    276                    UErrorCode *pErrorCode);
    277 
    278 /**
    279  * Get a unique base skeleton from a given pattern. This is the same
    280  * as the skeleton, except that differences in length are minimized so
    281  * as to only preserve the difference between string and numeric form. So
    282  * for example, both "MMM-dd" and "d/MMM" produce the skeleton "MMMd"
    283  * (notice the single d).
    284  *
    285  * Note that this function uses a non-const UDateTimePatternGenerator:
    286  * It uses a stateful pattern parser which is set up for each generator object,
    287  * rather than creating one for each function call.
    288  * Consecutive calls to this function do not affect each other,
    289  * but this function cannot be used concurrently on a single generator object.
    290  *
    291  * @param dtpg     a pointer to UDateTimePatternGenerator.
    292  * @param pattern  input pattern, such as "dd/MMM".
    293  * @param length   the length of pattern.
    294  * @param baseSkeleton such as "Md"
    295  * @param capacity the capacity of base skeleton.
    296  * @param pErrorCode a pointer to the UErrorCode which must not indicate a
    297  *                  failure before the function call.
    298  * @return the length of baseSkeleton.
    299  * @stable ICU 3.8
    300  */
    301 U_STABLE int32_t U_EXPORT2
    302 udatpg_getBaseSkeleton(UDateTimePatternGenerator *dtpg,
    303                        const UChar *pattern, int32_t length,
    304                        UChar *baseSkeleton, int32_t capacity,
    305                        UErrorCode *pErrorCode);
    306 
    307 /**
    308  * Adds a pattern to the generator. If the pattern has the same skeleton as
    309  * an existing pattern, and the override parameter is set, then the previous
    310  * value is overriden. Otherwise, the previous value is retained. In either
    311  * case, the conflicting status is set and previous vale is stored in
    312  * conflicting pattern.
    313  * <p>
    314  * Note that single-field patterns (like "MMM") are automatically added, and
    315  * don't need to be added explicitly!
    316  *
    317  * @param dtpg     a pointer to UDateTimePatternGenerator.
    318  * @param pattern  input pattern, such as "dd/MMM"
    319  * @param patternLength the length of pattern.
    320  * @param override  When existing values are to be overridden use true,
    321  *                  otherwise use false.
    322  * @param conflictingPattern  Previous pattern with the same skeleton.
    323  * @param capacity the capacity of conflictingPattern.
    324  * @param pLength a pointer to the length of conflictingPattern.
    325  * @param pErrorCode a pointer to the UErrorCode which must not indicate a
    326  *                  failure before the function call.
    327  * @return conflicting status. The value could be UDATPG_NO_CONFLICT,
    328  *                  UDATPG_BASE_CONFLICT or UDATPG_CONFLICT.
    329  * @stable ICU 3.8
    330  */
    331 U_STABLE UDateTimePatternConflict U_EXPORT2
    332 udatpg_addPattern(UDateTimePatternGenerator *dtpg,
    333                   const UChar *pattern, int32_t patternLength,
    334                   UBool override,
    335                   UChar *conflictingPattern, int32_t capacity, int32_t *pLength,
    336                   UErrorCode *pErrorCode);
    337 
    338 /**
    339   * An AppendItem format is a pattern used to append a field if there is no
    340   * good match. For example, suppose that the input skeleton is "GyyyyMMMd",
    341   * and there is no matching pattern internally, but there is a pattern
    342   * matching "yyyyMMMd", say "d-MM-yyyy". Then that pattern is used, plus the
    343   * G. The way these two are conjoined is by using the AppendItemFormat for G
    344   * (era). So if that value is, say "{0}, {1}" then the final resulting
    345   * pattern is "d-MM-yyyy, G".
    346   * <p>
    347   * There are actually three available variables: {0} is the pattern so far,
    348   * {1} is the element we are adding, and {2} is the name of the element.
    349   * <p>
    350   * This reflects the way that the CLDR data is organized.
    351   *
    352   * @param dtpg   a pointer to UDateTimePatternGenerator.
    353   * @param field  UDateTimePatternField, such as UDATPG_ERA_FIELD
    354   * @param value  pattern, such as "{0}, {1}"
    355   * @param length the length of value.
    356   * @stable ICU 3.8
    357   */
    358 U_STABLE void U_EXPORT2
    359 udatpg_setAppendItemFormat(UDateTimePatternGenerator *dtpg,
    360                            UDateTimePatternField field,
    361                            const UChar *value, int32_t length);
    362 
    363 /**
    364  * Getter corresponding to setAppendItemFormat. Values below 0 or at or
    365  * above UDATPG_FIELD_COUNT are illegal arguments.
    366  *
    367  * @param dtpg   A pointer to UDateTimePatternGenerator.
    368  * @param field  UDateTimePatternField, such as UDATPG_ERA_FIELD
    369  * @param pLength A pointer that will receive the length of appendItemFormat.
    370  * @return appendItemFormat for field.
    371  * @stable ICU 3.8
    372  */
    373 U_STABLE const UChar * U_EXPORT2
    374 udatpg_getAppendItemFormat(const UDateTimePatternGenerator *dtpg,
    375                            UDateTimePatternField field,
    376                            int32_t *pLength);
    377 
    378 /**
    379    * Set the name of field, eg "era" in English for ERA. These are only
    380    * used if the corresponding AppendItemFormat is used, and if it contains a
    381    * {2} variable.
    382    * <p>
    383    * This reflects the way that the CLDR data is organized.
    384    *
    385    * @param dtpg   a pointer to UDateTimePatternGenerator.
    386    * @param field  UDateTimePatternField
    387    * @param value  name for the field.
    388    * @param length the length of value.
    389    * @stable ICU 3.8
    390    */
    391 U_STABLE void U_EXPORT2
    392 udatpg_setAppendItemName(UDateTimePatternGenerator *dtpg,
    393                          UDateTimePatternField field,
    394                          const UChar *value, int32_t length);
    395 
    396 /**
    397  * Getter corresponding to setAppendItemNames. Values below 0 or at or above
    398  * UDATPG_FIELD_COUNT are illegal arguments.
    399  *
    400  * @param dtpg   a pointer to UDateTimePatternGenerator.
    401  * @param field  UDateTimePatternField, such as UDATPG_ERA_FIELD
    402  * @param pLength A pointer that will receive the length of the name for field.
    403  * @return name for field
    404  * @stable ICU 3.8
    405  */
    406 U_STABLE const UChar * U_EXPORT2
    407 udatpg_getAppendItemName(const UDateTimePatternGenerator *dtpg,
    408                          UDateTimePatternField field,
    409                          int32_t *pLength);
    410 
    411 /**
    412  * The date time format is a message format pattern used to compose date and
    413  * time patterns. The default value is "{0} {1}", where {0} will be replaced
    414  * by the date pattern and {1} will be replaced by the time pattern.
    415  * <p>
    416  * This is used when the input skeleton contains both date and time fields,
    417  * but there is not a close match among the added patterns. For example,
    418  * suppose that this object was created by adding "dd-MMM" and "hh:mm", and
    419  * its datetimeFormat is the default "{0} {1}". Then if the input skeleton
    420  * is "MMMdhmm", there is not an exact match, so the input skeleton is
    421  * broken up into two components "MMMd" and "hmm". There are close matches
    422  * for those two skeletons, so the result is put together with this pattern,
    423  * resulting in "d-MMM h:mm".
    424  *
    425  * @param dtpg a pointer to UDateTimePatternGenerator.
    426  * @param dtFormat
    427  *            message format pattern, here {0} will be replaced by the date
    428  *            pattern and {1} will be replaced by the time pattern.
    429  * @param length the length of dtFormat.
    430  * @stable ICU 3.8
    431  */
    432 U_STABLE void U_EXPORT2
    433 udatpg_setDateTimeFormat(const UDateTimePatternGenerator *dtpg,
    434                          const UChar *dtFormat, int32_t length);
    435 
    436 /**
    437  * Getter corresponding to setDateTimeFormat.
    438  * @param dtpg   a pointer to UDateTimePatternGenerator.
    439  * @param pLength A pointer that will receive the length of the format
    440  * @return dateTimeFormat.
    441  * @stable ICU 3.8
    442  */
    443 U_STABLE const UChar * U_EXPORT2
    444 udatpg_getDateTimeFormat(const UDateTimePatternGenerator *dtpg,
    445                          int32_t *pLength);
    446 
    447 /**
    448  * The decimal value is used in formatting fractions of seconds. If the
    449  * skeleton contains fractional seconds, then this is used with the
    450  * fractional seconds. For example, suppose that the input pattern is
    451  * "hhmmssSSSS", and the best matching pattern internally is "H:mm:ss", and
    452  * the decimal string is ",". Then the resulting pattern is modified to be
    453  * "H:mm:ss,SSSS"
    454  *
    455  * @param dtpg a pointer to UDateTimePatternGenerator.
    456  * @param decimal
    457  * @param length the length of decimal.
    458  * @stable ICU 3.8
    459  */
    460 U_STABLE void U_EXPORT2
    461 udatpg_setDecimal(UDateTimePatternGenerator *dtpg,
    462                   const UChar *decimal, int32_t length);
    463 
    464 /**
    465  * Getter corresponding to setDecimal.
    466  *
    467  * @param dtpg a pointer to UDateTimePatternGenerator.
    468  * @param pLength A pointer that will receive the length of the decimal string.
    469  * @return corresponding to the decimal point.
    470  * @stable ICU 3.8
    471  */
    472 U_STABLE const UChar * U_EXPORT2
    473 udatpg_getDecimal(const UDateTimePatternGenerator *dtpg,
    474                   int32_t *pLength);
    475 
    476 /**
    477  * Adjusts the field types (width and subtype) of a pattern to match what is
    478  * in a skeleton. That is, if you supply a pattern like "d-M H:m", and a
    479  * skeleton of "MMMMddhhmm", then the input pattern is adjusted to be
    480  * "dd-MMMM hh:mm". This is used internally to get the best match for the
    481  * input skeleton, but can also be used externally.
    482  *
    483  * Note that this function uses a non-const UDateTimePatternGenerator:
    484  * It uses a stateful pattern parser which is set up for each generator object,
    485  * rather than creating one for each function call.
    486  * Consecutive calls to this function do not affect each other,
    487  * but this function cannot be used concurrently on a single generator object.
    488  *
    489  * @param dtpg a pointer to UDateTimePatternGenerator.
    490  * @param pattern Input pattern
    491  * @param patternLength the length of input pattern.
    492  * @param skeleton
    493  * @param skeletonLength the length of input skeleton.
    494  * @param dest  pattern adjusted to match the skeleton fields widths and subtypes.
    495  * @param destCapacity the capacity of dest.
    496  * @param pErrorCode a pointer to the UErrorCode which must not indicate a
    497  *                  failure before the function call.
    498  * @return the length of dest.
    499  * @stable ICU 3.8
    500  */
    501 U_STABLE int32_t U_EXPORT2
    502 udatpg_replaceFieldTypes(UDateTimePatternGenerator *dtpg,
    503                          const UChar *pattern, int32_t patternLength,
    504                          const UChar *skeleton, int32_t skeletonLength,
    505                          UChar *dest, int32_t destCapacity,
    506                          UErrorCode *pErrorCode);
    507 
    508 /**
    509  * Adjusts the field types (width and subtype) of a pattern to match what is
    510  * in a skeleton. That is, if you supply a pattern like "d-M H:m", and a
    511  * skeleton of "MMMMddhhmm", then the input pattern is adjusted to be
    512  * "dd-MMMM hh:mm". This is used internally to get the best match for the
    513  * input skeleton, but can also be used externally.
    514  *
    515  * Note that this function uses a non-const UDateTimePatternGenerator:
    516  * It uses a stateful pattern parser which is set up for each generator object,
    517  * rather than creating one for each function call.
    518  * Consecutive calls to this function do not affect each other,
    519  * but this function cannot be used concurrently on a single generator object.
    520  *
    521  * @param dtpg a pointer to UDateTimePatternGenerator.
    522  * @param pattern Input pattern
    523  * @param patternLength the length of input pattern.
    524  * @param skeleton
    525  * @param skeletonLength the length of input skeleton.
    526  * @param options
    527  *            Options controlling whether the length of specified fields in the
    528  *            pattern are adjusted to match those in the skeleton (when this
    529  *            would not happen otherwise). For default behavior, use
    530  *            UDATPG_MATCH_NO_OPTIONS.
    531  * @param dest  pattern adjusted to match the skeleton fields widths and subtypes.
    532  * @param destCapacity the capacity of dest.
    533  * @param pErrorCode a pointer to the UErrorCode which must not indicate a
    534  *                  failure before the function call.
    535  * @return the length of dest.
    536  * @stable ICU 4.4
    537  */
    538 U_STABLE int32_t U_EXPORT2
    539 udatpg_replaceFieldTypesWithOptions(UDateTimePatternGenerator *dtpg,
    540                                     const UChar *pattern, int32_t patternLength,
    541                                     const UChar *skeleton, int32_t skeletonLength,
    542                                     UDateTimePatternMatchOptions options,
    543                                     UChar *dest, int32_t destCapacity,
    544                                     UErrorCode *pErrorCode);
    545 
    546 /**
    547  * Return a UEnumeration list of all the skeletons in canonical form.
    548  * Call udatpg_getPatternForSkeleton() to get the corresponding pattern.
    549  *
    550  * @param dtpg a pointer to UDateTimePatternGenerator.
    551  * @param pErrorCode a pointer to the UErrorCode which must not indicate a
    552  *                  failure before the function call
    553  * @return a UEnumeration list of all the skeletons
    554  *         The caller must close the object.
    555  * @stable ICU 3.8
    556  */
    557 U_STABLE UEnumeration * U_EXPORT2
    558 udatpg_openSkeletons(const UDateTimePatternGenerator *dtpg, UErrorCode *pErrorCode);
    559 
    560 /**
    561  * Return a UEnumeration list of all the base skeletons in canonical form.
    562  *
    563  * @param dtpg a pointer to UDateTimePatternGenerator.
    564  * @param pErrorCode a pointer to the UErrorCode which must not indicate a
    565  *             failure before the function call.
    566  * @return a UEnumeration list of all the base skeletons
    567  *             The caller must close the object.
    568  * @stable ICU 3.8
    569  */
    570 U_STABLE UEnumeration * U_EXPORT2
    571 udatpg_openBaseSkeletons(const UDateTimePatternGenerator *dtpg, UErrorCode *pErrorCode);
    572 
    573 /**
    574  * Get the pattern corresponding to a given skeleton.
    575  *
    576  * @param dtpg a pointer to UDateTimePatternGenerator.
    577  * @param skeleton
    578  * @param skeletonLength pointer to the length of skeleton.
    579  * @param pLength pointer to the length of return pattern.
    580  * @return pattern corresponding to a given skeleton.
    581  * @stable ICU 3.8
    582  */
    583 U_STABLE const UChar * U_EXPORT2
    584 udatpg_getPatternForSkeleton(const UDateTimePatternGenerator *dtpg,
    585                              const UChar *skeleton, int32_t skeletonLength,
    586                              int32_t *pLength);
    587 
    588 #endif
    589