[INTL] Implement Intl.DateTimeFormat.prototype.resolvedOptions ()
[WebKit.git] / Source / JavaScriptCore / icu / 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