The Tor Browser / file comparison

comparison: intl/icu/source/i18n/unicode/udatpg.h

intl/icu/source/i18n/unicode/udatpg.h

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:420cfef87889
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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial