icuSources/i18n/unicode/udatpg.h

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