icuSources/i18n/unicode/udatpg.h

   1 /*
   2 *******************************************************************************
   3 *
   4 *   Copyright (C) 2007-2011, 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 #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