Mercurial > repos > rliterman > csp2

comparison CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/unicode/dtptngen.h @ 69:33d812a61356

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
planemo upload commit 2e9511a184a1ca667c7be0c6321a36dc4e3d116d
author jpayne
date Tue, 18 Mar 2025 17:55:14 -0400
parents
children
comparison
equal deleted inserted replaced
67:0e9998148a16 69:33d812a61356
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 *******************************************************************************
5 * Copyright (C) 2007-2016, International Business Machines Corporation and
6 * others. All Rights Reserved.
7 *******************************************************************************
8 *
9 * File DTPTNGEN.H
10 *
11 *******************************************************************************
12 */
13
14 #ifndef __DTPTNGEN_H__
15 #define __DTPTNGEN_H__
16
17 #include "unicode/utypes.h"
18
19 #if U_SHOW_CPLUSPLUS_API
20
21 #include "unicode/datefmt.h"
22 #include "unicode/locid.h"
23 #include "unicode/udat.h"
24 #include "unicode/udatpg.h"
25 #include "unicode/unistr.h"
26
27 U_NAMESPACE_BEGIN
28
29 /**
30 * \file
31 * \brief C++ API: Date/Time Pattern Generator
32 */
33
34
35 class CharString;
36 class Hashtable;
37 class FormatParser;
38 class DateTimeMatcher;
39 class DistanceInfo;
40 class PatternMap;
41 class PtnSkeleton;
42 class SharedDateTimePatternGenerator;
43
44 /**
45 * This class provides flexible generation of date format patterns, like "yy-MM-dd".
46 * The user can build up the generator by adding successive patterns. Once that
47 * is done, a query can be made using a "skeleton", which is a pattern which just
48 * includes the desired fields and lengths. The generator will return the "best fit"
49 * pattern corresponding to that skeleton.
50 * <p>The main method people will use is getBestPattern(String skeleton),
51 * since normally this class is pre-built with data from a particular locale.
52 * However, generators can be built directly from other data as well.
53 * <p><i>Issue: may be useful to also have a function that returns the list of
54 * fields in a pattern, in order, since we have that internally.
55 * That would be useful for getting the UI order of field elements.</i>
56 * @stable ICU 3.8
57 **/
58 class U_I18N_API DateTimePatternGenerator : public UObject {
59 public:
60 /**
61 * Construct a flexible generator according to default locale.
62 * @param status Output param set to success/failure code on exit,
63 * which must not indicate a failure before the function call.
64 * @stable ICU 3.8
65 */
66 static DateTimePatternGenerator* U_EXPORT2 createInstance(UErrorCode& status);
67
68 /**
69 * Construct a flexible generator according to data for a given locale.
70 * @param uLocale
71 * @param status Output param set to success/failure code on exit,
72 * which must not indicate a failure before the function call.
73 * @stable ICU 3.8
74 */
75 static DateTimePatternGenerator* U_EXPORT2 createInstance(const Locale& uLocale, UErrorCode& status);
76
77 #ifndef U_HIDE_INTERNAL_API
78
79 /**
80 * For ICU use only
81 *
82 * @internal
83 */
84 static DateTimePatternGenerator* U_EXPORT2 internalMakeInstance(const Locale& uLocale, UErrorCode& status);
85
86 #endif /* U_HIDE_INTERNAL_API */
87
88 /**
89 * Create an empty generator, to be constructed with addPattern(...) etc.
90 * @param status Output param set to success/failure code on exit,
91 * which must not indicate a failure before the function call.
92 * @stable ICU 3.8
93 */
94 static DateTimePatternGenerator* U_EXPORT2 createEmptyInstance(UErrorCode& status);
95
96 /**
97 * Destructor.
98 * @stable ICU 3.8
99 */
100 virtual ~DateTimePatternGenerator();
101
102 /**
103 * Clone DateTimePatternGenerator object. Clients are responsible for
104 * deleting the DateTimePatternGenerator object cloned.
105 * @stable ICU 3.8
106 */
107 DateTimePatternGenerator* clone() const;
108
109 /**
110 * Return true if another object is semantically equal to this one.
111 *
112 * @param other the DateTimePatternGenerator object to be compared with.
113 * @return true if other is semantically equal to this.
114 * @stable ICU 3.8
115 */
116 UBool operator==(const DateTimePatternGenerator& other) const;
117
118 /**
119 * Return true if another object is semantically unequal to this one.
120 *
121 * @param other the DateTimePatternGenerator object to be compared with.
122 * @return true if other is semantically unequal to this.
123 * @stable ICU 3.8
124 */
125 UBool operator!=(const DateTimePatternGenerator& other) const;
126
127 /**
128 * Utility to return a unique skeleton from a given pattern. For example,
129 * both "MMM-dd" and "dd/MMM" produce the skeleton "MMMdd".
130 *
131 * @param pattern Input pattern, such as "dd/MMM"
132 * @param status Output param set to success/failure code on exit,
133 * which must not indicate a failure before the function call.
134 * @return skeleton such as "MMMdd"
135 * @stable ICU 56
136 */
137 static UnicodeString staticGetSkeleton(const UnicodeString& pattern, UErrorCode& status);
138
139 /**
140 * Utility to return a unique skeleton from a given pattern. For example,
141 * both "MMM-dd" and "dd/MMM" produce the skeleton "MMMdd".
142 * getSkeleton() works exactly like staticGetSkeleton().
143 * Use staticGetSkeleton() instead of getSkeleton().
144 *
145 * @param pattern Input pattern, such as "dd/MMM"
146 * @param status Output param set to success/failure code on exit,
147 * which must not indicate a failure before the function call.
148 * @return skeleton such as "MMMdd"
149 * @stable ICU 3.8
150 */
151 UnicodeString getSkeleton(const UnicodeString& pattern, UErrorCode& status); /* {
152 The function is commented out because it is a stable API calling a draft API.
153 After staticGetSkeleton becomes stable, staticGetSkeleton can be used and
154 these comments and the definition of getSkeleton in dtptngen.cpp should be removed.
155 return staticGetSkeleton(pattern, status);
156 }*/
157
158 /**
159 * Utility to return a unique base skeleton from a given pattern. This is
160 * the same as the skeleton, except that differences in length are minimized
161 * so as to only preserve the difference between string and numeric form. So
162 * for example, both "MMM-dd" and "d/MMM" produce the skeleton "MMMd"
163 * (notice the single d).
164 *
165 * @param pattern Input pattern, such as "dd/MMM"
166 * @param status Output param set to success/failure code on exit,
167 * which must not indicate a failure before the function call.
168 * @return base skeleton, such as "MMMd"
169 * @stable ICU 56
170 */
171 static UnicodeString staticGetBaseSkeleton(const UnicodeString& pattern, UErrorCode& status);
172
173 /**
174 * Utility to return a unique base skeleton from a given pattern. This is
175 * the same as the skeleton, except that differences in length are minimized
176 * so as to only preserve the difference between string and numeric form. So
177 * for example, both "MMM-dd" and "d/MMM" produce the skeleton "MMMd"
178 * (notice the single d).
179 * getBaseSkeleton() works exactly like staticGetBaseSkeleton().
180 * Use staticGetBaseSkeleton() instead of getBaseSkeleton().
181 *
182 * @param pattern Input pattern, such as "dd/MMM"
183 * @param status Output param set to success/failure code on exit,
184 * which must not indicate a failure before the function call.
185 * @return base skeleton, such as "MMMd"
186 * @stable ICU 3.8
187 */
188 UnicodeString getBaseSkeleton(const UnicodeString& pattern, UErrorCode& status); /* {
189 The function is commented out because it is a stable API calling a draft API.
190 After staticGetBaseSkeleton becomes stable, staticGetBaseSkeleton can be used and
191 these comments and the definition of getBaseSkeleton in dtptngen.cpp should be removed.
192 return staticGetBaseSkeleton(pattern, status);
193 }*/
194
195 /**
196 * Adds a pattern to the generator. If the pattern has the same skeleton as
197 * an existing pattern, and the override parameter is set, then the previous
198 * value is overriden. Otherwise, the previous value is retained. In either
199 * case, the conflicting status is set and previous vale is stored in
200 * conflicting pattern.
201 * <p>
202 * Note that single-field patterns (like "MMM") are automatically added, and
203 * don't need to be added explicitly!
204 *
205 * @param pattern Input pattern, such as "dd/MMM"
206 * @param override When existing values are to be overridden use true,
207 * otherwise use false.
208 * @param conflictingPattern Previous pattern with the same skeleton.
209 * @param status Output param set to success/failure code on exit,
210 * which must not indicate a failure before the function call.
211 * @return conflicting status. The value could be UDATPG_NO_CONFLICT,
212 * UDATPG_BASE_CONFLICT or UDATPG_CONFLICT.
213 * @stable ICU 3.8
214 * <p>
215 * <h4>Sample code</h4>
216 * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample1
217 * \snippet samples/dtptngsample/dtptngsample.cpp addPatternExample
218 * <p>
219 */
220 UDateTimePatternConflict addPattern(const UnicodeString& pattern,
221 UBool override,
222 UnicodeString& conflictingPattern,
223 UErrorCode& status);
224
225 /**
226 * An AppendItem format is a pattern used to append a field if there is no
227 * good match. For example, suppose that the input skeleton is "GyyyyMMMd",
228 * and there is no matching pattern internally, but there is a pattern
229 * matching "yyyyMMMd", say "d-MM-yyyy". Then that pattern is used, plus the
230 * G. The way these two are conjoined is by using the AppendItemFormat for G
231 * (era). So if that value is, say "{0}, {1}" then the final resulting
232 * pattern is "d-MM-yyyy, G".
233 * <p>
234 * There are actually three available variables: {0} is the pattern so far,
235 * {1} is the element we are adding, and {2} is the name of the element.
236 * <p>
237 * This reflects the way that the CLDR data is organized.
238 *
239 * @param field such as UDATPG_ERA_FIELD.
240 * @param value pattern, such as "{0}, {1}"
241 * @stable ICU 3.8
242 */
243 void setAppendItemFormat(UDateTimePatternField field, const UnicodeString& value);
244
245 /**
246 * Getter corresponding to setAppendItemFormat. Values below 0 or at or
247 * above UDATPG_FIELD_COUNT are illegal arguments.
248 *
249 * @param field such as UDATPG_ERA_FIELD.
250 * @return append pattern for field
251 * @stable ICU 3.8
252 */
253 const UnicodeString& getAppendItemFormat(UDateTimePatternField field) const;
254
255 /**
256 * Sets the names of field, eg "era" in English for ERA. These are only
257 * used if the corresponding AppendItemFormat is used, and if it contains a
258 * {2} variable.
259 * <p>
260 * This reflects the way that the CLDR data is organized.
261 *
262 * @param field such as UDATPG_ERA_FIELD.
263 * @param value name of the field
264 * @stable ICU 3.8
265 */
266 void setAppendItemName(UDateTimePatternField field, const UnicodeString& value);
267
268 /**
269 * Getter corresponding to setAppendItemNames. Values below 0 or at or above
270 * UDATPG_FIELD_COUNT are illegal arguments. Note: The more general method
271 * for getting date/time field display names is getFieldDisplayName.
272 *
273 * @param field such as UDATPG_ERA_FIELD.
274 * @return name for field
275 * @see getFieldDisplayName
276 * @stable ICU 3.8
277 */
278 const UnicodeString& getAppendItemName(UDateTimePatternField field) const;
279
280 /**
281 * The general interface to get a display name for a particular date/time field,
282 * in one of several possible display widths.
283 *
284 * @param field The desired UDateTimePatternField, such as UDATPG_ERA_FIELD.
285 * @param width The desired UDateTimePGDisplayWidth, such as UDATPG_ABBREVIATED.
286 * @return The display name for field
287 * @stable ICU 61
288 */
289 UnicodeString getFieldDisplayName(UDateTimePatternField field, UDateTimePGDisplayWidth width) const;
290
291 /**
292 * The DateTimeFormat is a message format pattern used to compose date and
293 * time patterns. The default pattern in the root locale is "{1} {0}", where
294 * {1} will be replaced by the date pattern and {0} will be replaced by the
295 * time pattern; however, other locales may specify patterns such as
296 * "{1}, {0}" or "{1} 'at' {0}", etc.
297 * <p>
298 * This is used when the input skeleton contains both date and time fields,
299 * but there is not a close match among the added patterns. For example,
300 * suppose that this object was created by adding "dd-MMM" and "hh:mm", and
301 * its datetimeFormat is the default "{1} {0}". Then if the input skeleton
302 * is "MMMdhmm", there is not an exact match, so the input skeleton is
303 * broken up into two components "MMMd" and "hmm". There are close matches
304 * for those two skeletons, so the result is put together with this pattern,
305 * resulting in "d-MMM h:mm".
306 *
307 * @param dateTimeFormat
308 * message format pattern, here {1} will be replaced by the date
309 * pattern and {0} will be replaced by the time pattern.
310 * @stable ICU 3.8
311 */
312 void setDateTimeFormat(const UnicodeString& dateTimeFormat);
313
314 /**
315 * Getter corresponding to setDateTimeFormat.
316 * @return DateTimeFormat.
317 * @stable ICU 3.8
318 */
319 const UnicodeString& getDateTimeFormat() const;
320
321 /**
322 * Return the best pattern matching the input skeleton. It is guaranteed to
323 * have all of the fields in the skeleton.
324 *
325 * @param skeleton
326 * The skeleton is a pattern containing only the variable fields.
327 * For example, "MMMdd" and "mmhh" are skeletons.
328 * @param status Output param set to success/failure code on exit,
329 * which must not indicate a failure before the function call.
330 * @return bestPattern
331 * The best pattern found from the given skeleton.
332 * @stable ICU 3.8
333 * <p>
334 * <h4>Sample code</h4>
335 * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample1
336 * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample
337 * <p>
338 */
339 UnicodeString getBestPattern(const UnicodeString& skeleton, UErrorCode& status);
340
341
342 /**
343 * Return the best pattern matching the input skeleton. It is guaranteed to
344 * have all of the fields in the skeleton.
345 *
346 * @param skeleton
347 * The skeleton is a pattern containing only the variable fields.
348 * For example, "MMMdd" and "mmhh" are skeletons.
349 * @param options
350 * Options for forcing the length of specified fields in the
351 * returned pattern to match those in the skeleton (when this
352 * would not happen otherwise). For default behavior, use
353 * UDATPG_MATCH_NO_OPTIONS.
354 * @param status
355 * Output param set to success/failure code on exit,
356 * which must not indicate a failure before the function call.
357 * @return bestPattern
358 * The best pattern found from the given skeleton.
359 * @stable ICU 4.4
360 */
361 UnicodeString getBestPattern(const UnicodeString& skeleton,
362 UDateTimePatternMatchOptions options,
363 UErrorCode& status);
364
365
366 /**
367 * Adjusts the field types (width and subtype) of a pattern to match what is
368 * in a skeleton. That is, if you supply a pattern like "d-M H:m", and a
369 * skeleton of "MMMMddhhmm", then the input pattern is adjusted to be
370 * "dd-MMMM hh:mm". This is used internally to get the best match for the
371 * input skeleton, but can also be used externally.
372 *
373 * @param pattern Input pattern
374 * @param skeleton
375 * The skeleton is a pattern containing only the variable fields.
376 * For example, "MMMdd" and "mmhh" are skeletons.
377 * @param status Output param set to success/failure code on exit,
378 * which must not indicate a failure before the function call.
379 * @return pattern adjusted to match the skeleton fields widths and subtypes.
380 * @stable ICU 3.8
381 * <p>
382 * <h4>Sample code</h4>
383 * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample1
384 * \snippet samples/dtptngsample/dtptngsample.cpp replaceFieldTypesExample
385 * <p>
386 */
387 UnicodeString replaceFieldTypes(const UnicodeString& pattern,
388 const UnicodeString& skeleton,
389 UErrorCode& status);
390
391 /**
392 * Adjusts the field types (width and subtype) of a pattern to match what is
393 * in a skeleton. That is, if you supply a pattern like "d-M H:m", and a
394 * skeleton of "MMMMddhhmm", then the input pattern is adjusted to be
395 * "dd-MMMM hh:mm". This is used internally to get the best match for the
396 * input skeleton, but can also be used externally.
397 *
398 * @param pattern Input pattern
399 * @param skeleton
400 * The skeleton is a pattern containing only the variable fields.
401 * For example, "MMMdd" and "mmhh" are skeletons.
402 * @param options
403 * Options controlling whether the length of specified fields in the
404 * pattern are adjusted to match those in the skeleton (when this
405 * would not happen otherwise). For default behavior, use
406 * UDATPG_MATCH_NO_OPTIONS.
407 * @param status
408 * Output param set to success/failure code on exit,
409 * which must not indicate a failure before the function call.
410 * @return pattern adjusted to match the skeleton fields widths and subtypes.
411 * @stable ICU 4.4
412 */
413 UnicodeString replaceFieldTypes(const UnicodeString& pattern,
414 const UnicodeString& skeleton,
415 UDateTimePatternMatchOptions options,
416 UErrorCode& status);
417
418 /**
419 * Return a list of all the skeletons (in canonical form) from this class.
420 *
421 * Call getPatternForSkeleton() to get the corresponding pattern.
422 *
423 * @param status Output param set to success/failure code on exit,
424 * which must not indicate a failure before the function call.
425 * @return StringEnumeration with the skeletons.
426 * The caller must delete the object.
427 * @stable ICU 3.8
428 */
429 StringEnumeration* getSkeletons(UErrorCode& status) const;
430
431 /**
432 * Get the pattern corresponding to a given skeleton.
433 * @param skeleton
434 * @return pattern corresponding to a given skeleton.
435 * @stable ICU 3.8
436 */
437 const UnicodeString& getPatternForSkeleton(const UnicodeString& skeleton) const;
438
439 /**
440 * Return a list of all the base skeletons (in canonical form) from this class.
441 *
442 * @param status Output param set to success/failure code on exit,
443 * which must not indicate a failure before the function call.
444 * @return a StringEnumeration with the base skeletons.
445 * The caller must delete the object.
446 * @stable ICU 3.8
447 */
448 StringEnumeration* getBaseSkeletons(UErrorCode& status) const;
449
450 #ifndef U_HIDE_INTERNAL_API
451 /**
452 * Return a list of redundant patterns are those which if removed, make no
453 * difference in the resulting getBestPattern values. This method returns a
454 * list of them, to help check the consistency of the patterns used to build
455 * this generator.
456 *
457 * @param status Output param set to success/failure code on exit,
458 * which must not indicate a failure before the function call.
459 * @return a StringEnumeration with the redundant pattern.
460 * The caller must delete the object.
461 * @internal ICU 3.8
462 */
463 StringEnumeration* getRedundants(UErrorCode& status);
464 #endif /* U_HIDE_INTERNAL_API */
465
466 /**
467 * The decimal value is used in formatting fractions of seconds. If the
468 * skeleton contains fractional seconds, then this is used with the
469 * fractional seconds. For example, suppose that the input pattern is
470 * "hhmmssSSSS", and the best matching pattern internally is "H:mm:ss", and
471 * the decimal string is ",". Then the resulting pattern is modified to be
472 * "H:mm:ss,SSSS"
473 *
474 * @param decimal
475 * @stable ICU 3.8
476 */
477 void setDecimal(const UnicodeString& decimal);
478
479 /**
480 * Getter corresponding to setDecimal.
481 * @return UnicodeString corresponding to the decimal point
482 * @stable ICU 3.8
483 */
484 const UnicodeString& getDecimal() const;
485
486 #if !UCONFIG_NO_FORMATTING
487
488 #ifndef U_HIDE_DRAFT_API
489 /**
490 * Get the default hour cycle for a locale. Uses the locale that the
491 * DateTimePatternGenerator was initially created with.
492 *
493 * Cannot be used on an empty DateTimePatternGenerator instance.
494 *
495 * @param status Output param set to success/failure code on exit, which
496 * which must not indicate a failure before the function call.
497 * Set to U_UNSUPPORTED_ERROR if used on an empty instance.
498 * @return the default hour cycle.
499 * @draft ICU 67
500 */
501 UDateFormatHourCycle getDefaultHourCycle(UErrorCode& status) const;
502 #endif /* U_HIDE_DRAFT_API */
503
504 #endif /* #if !UCONFIG_NO_FORMATTING */
505
506 /**
507 * ICU "poor man's RTTI", returns a UClassID for the actual class.
508 *
509 * @stable ICU 3.8
510 */
511 virtual UClassID getDynamicClassID() const;
512
513 /**
514 * ICU "poor man's RTTI", returns a UClassID for this class.
515 *
516 * @stable ICU 3.8
517 */
518 static UClassID U_EXPORT2 getStaticClassID(void);
519
520 private:
521 /**
522 * Constructor.
523 */
524 DateTimePatternGenerator(UErrorCode & status);
525
526 /**
527 * Constructor.
528 */
529 DateTimePatternGenerator(const Locale& locale, UErrorCode & status);
530
531 /**
532 * Copy constructor.
533 * @param other DateTimePatternGenerator to copy
534 */
535 DateTimePatternGenerator(const DateTimePatternGenerator& other);
536
537 /**
538 * Default assignment operator.
539 * @param other DateTimePatternGenerator to copy
540 */
541 DateTimePatternGenerator& operator=(const DateTimePatternGenerator& other);
542
543 // TODO(ticket:13619): re-enable when UDATPG_NARROW no longer in draft mode.
544 // static const int32_t UDATPG_WIDTH_COUNT = UDATPG_NARROW + 1;
545
546 Locale pLocale; // pattern locale
547 FormatParser *fp;
548 DateTimeMatcher* dtMatcher;
549 DistanceInfo *distanceInfo;
550 PatternMap *patternMap;
551 UnicodeString appendItemFormats[UDATPG_FIELD_COUNT];
552 // TODO(ticket:13619): [3] -> UDATPG_WIDTH_COUNT
553 UnicodeString fieldDisplayNames[UDATPG_FIELD_COUNT][3];
554 UnicodeString dateTimeFormat;
555 UnicodeString decimal;
556 DateTimeMatcher *skipMatcher;
557 Hashtable *fAvailableFormatKeyHash;
558 UnicodeString emptyString;
559 char16_t fDefaultHourFormatChar;
560
561 int32_t fAllowedHourFormats[7]; // Actually an array of AllowedHourFormat enum type, ending with UNKNOWN.
562
563 // Internal error code used for recording/reporting errors that occur during methods that do not
564 // have a UErrorCode parameter. For example: the Copy Constructor, or the ::clone() method.
565 // When this is set to an error the object is in an invalid state.
566 UErrorCode internalErrorCode;
567
568 /* internal flags masks for adjustFieldTypes etc. */
569 enum {
570 kDTPGNoFlags = 0,
571 kDTPGFixFractionalSeconds = 1,
572 kDTPGSkeletonUsesCapJ = 2
573 // with #13183, no longer need flags for b, B
574 };
575
576 void initData(const Locale &locale, UErrorCode &status);
577 void addCanonicalItems(UErrorCode &status);
578 void addICUPatterns(const Locale& locale, UErrorCode& status);
579 void hackTimes(const UnicodeString& hackPattern, UErrorCode& status);
580 void getCalendarTypeToUse(const Locale& locale, CharString& destination, UErrorCode& err);
581 void consumeShortTimePattern(const UnicodeString& shortTimePattern, UErrorCode& status);
582 void addCLDRData(const Locale& locale, UErrorCode& status);
583 UDateTimePatternConflict addPatternWithSkeleton(const UnicodeString& pattern, const UnicodeString * skeletonToUse, UBool override, UnicodeString& conflictingPattern, UErrorCode& status);
584 void initHashtable(UErrorCode& status);
585 void setDateTimeFromCalendar(const Locale& locale, UErrorCode& status);
586 void setDecimalSymbols(const Locale& locale, UErrorCode& status);
587 UDateTimePatternField getAppendFormatNumber(const char* field) const;
588 // Note for the next 3: UDateTimePGDisplayWidth is now stable ICU 61
589 UDateTimePatternField getFieldAndWidthIndices(const char* key, UDateTimePGDisplayWidth* widthP) const;
590 void setFieldDisplayName(UDateTimePatternField field, UDateTimePGDisplayWidth width, const UnicodeString& value);
591 UnicodeString& getMutableFieldDisplayName(UDateTimePatternField field, UDateTimePGDisplayWidth width);
592 void getAppendName(UDateTimePatternField field, UnicodeString& value);
593 UnicodeString mapSkeletonMetacharacters(const UnicodeString& patternForm, int32_t* flags, UErrorCode& status);
594 const UnicodeString* getBestRaw(DateTimeMatcher& source, int32_t includeMask, DistanceInfo* missingFields, UErrorCode& status, const PtnSkeleton** specifiedSkeletonPtr = 0);
595 UnicodeString adjustFieldTypes(const UnicodeString& pattern, const PtnSkeleton* specifiedSkeleton, int32_t flags, UDateTimePatternMatchOptions options = UDATPG_MATCH_NO_OPTIONS);
596 UnicodeString getBestAppending(int32_t missingFields, int32_t flags, UErrorCode& status, UDateTimePatternMatchOptions options = UDATPG_MATCH_NO_OPTIONS);
597 int32_t getTopBitNumber(int32_t foundMask) const;
598 void setAvailableFormat(const UnicodeString &key, UErrorCode& status);
599 UBool isAvailableFormatSet(const UnicodeString &key) const;
600 void copyHashtable(Hashtable *other, UErrorCode &status);
601 UBool isCanonicalItem(const UnicodeString& item) const;
602 static void U_CALLCONV loadAllowedHourFormatsData(UErrorCode &status);
603 void getAllowedHourFormats(const Locale &locale, UErrorCode &status);
604
605 struct AppendItemFormatsSink;
606 struct AppendItemNamesSink;
607 struct AvailableFormatsSink;
608 } ;// end class DateTimePatternGenerator
609
610 U_NAMESPACE_END
611
612 #endif /* U_SHOW_CPLUSPLUS_API */
613
614 #endif