The Tor Browser / file comparison

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

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

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:1d7f350f5477
1 /*
2 *******************************************************************************
3 * Copyright (C) 2007-2013, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 *******************************************************************************
6 *
7 * File DTPTNGEN.H
8 *
9 *******************************************************************************
10 */
11
12 #ifndef __DTPTNGEN_H__
13 #define __DTPTNGEN_H__
14
15 #include "unicode/datefmt.h"
16 #include "unicode/locid.h"
17 #include "unicode/udat.h"
18 #include "unicode/udatpg.h"
19
20 U_NAMESPACE_BEGIN
21
22 /**
23 * \file
24 * \brief C++ API: Date/Time Pattern Generator
25 */
26
27
28 class Hashtable;
29 class FormatParser;
30 class DateTimeMatcher;
31 class DistanceInfo;
32 class PatternMap;
33 class PtnSkeleton;
34
35 /**
36 * This class provides flexible generation of date format patterns, like "yy-MM-dd".
37 * The user can build up the generator by adding successive patterns. Once that
38 * is done, a query can be made using a "skeleton", which is a pattern which just
39 * includes the desired fields and lengths. The generator will return the "best fit"
40 * pattern corresponding to that skeleton.
41 * <p>The main method people will use is getBestPattern(String skeleton),
42 * since normally this class is pre-built with data from a particular locale.
43 * However, generators can be built directly from other data as well.
44 * <p><i>Issue: may be useful to also have a function that returns the list of
45 * fields in a pattern, in order, since we have that internally.
46 * That would be useful for getting the UI order of field elements.</i>
47 * @stable ICU 3.8
48 **/
49 class U_I18N_API DateTimePatternGenerator : public UObject {
50 public:
51 /**
52 * Construct a flexible generator according to default locale.
53 * @param status Output param set to success/failure code on exit,
54 * which must not indicate a failure before the function call.
55 * @stable ICU 3.8
56 */
57 static DateTimePatternGenerator* U_EXPORT2 createInstance(UErrorCode& status);
58
59 /**
60 * Construct a flexible generator according to data for a given locale.
61 * @param uLocale
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(const Locale& uLocale, UErrorCode& status);
67
68 /**
69 * Create an empty generator, to be constructed with addPattern(...) etc.
70 * @param status Output param set to success/failure code on exit,
71 * which must not indicate a failure before the function call.
72 * @stable ICU 3.8
73 */
74 static DateTimePatternGenerator* U_EXPORT2 createEmptyInstance(UErrorCode& status);
75
76 /**
77 * Destructor.
78 * @stable ICU 3.8
79 */
80 virtual ~DateTimePatternGenerator();
81
82 /**
83 * Clone DateTimePatternGenerator object. Clients are responsible for
84 * deleting the DateTimePatternGenerator object cloned.
85 * @stable ICU 3.8
86 */
87 DateTimePatternGenerator* clone() const;
88
89 /**
90 * Return true if another object is semantically equal to this one.
91 *
92 * @param other the DateTimePatternGenerator object to be compared with.
93 * @return true if other is semantically equal to this.
94 * @stable ICU 3.8
95 */
96 UBool operator==(const DateTimePatternGenerator& other) const;
97
98 /**
99 * Return true if another object is semantically unequal to this one.
100 *
101 * @param other the DateTimePatternGenerator object to be compared with.
102 * @return true if other is semantically unequal to this.
103 * @stable ICU 3.8
104 */
105 UBool operator!=(const DateTimePatternGenerator& other) const;
106
107 /**
108 * Utility to return a unique skeleton from a given pattern. For example,
109 * both "MMM-dd" and "dd/MMM" produce the skeleton "MMMdd".
110 *
111 * @param pattern Input pattern, such as "dd/MMM"
112 * @param status Output param set to success/failure code on exit,
113 * which must not indicate a failure before the function call.
114 * @return skeleton such as "MMMdd"
115 * @stable ICU 3.8
116 */
117 UnicodeString getSkeleton(const UnicodeString& pattern, UErrorCode& status);
118
119 /**
120 * Utility to return a unique base skeleton from a given pattern. This is
121 * the same as the skeleton, except that differences in length are minimized
122 * so as to only preserve the difference between string and numeric form. So
123 * for example, both "MMM-dd" and "d/MMM" produce the skeleton "MMMd"
124 * (notice the single d).
125 *
126 * @param pattern Input pattern, such as "dd/MMM"
127 * @param status Output param set to success/failure code on exit,
128 * which must not indicate a failure before the function call.
129 * @return base skeleton, such as "Md"
130 * @stable ICU 3.8
131 */
132 UnicodeString getBaseSkeleton(const UnicodeString& pattern, UErrorCode& status);
133
134 /**
135 * Adds a pattern to the generator. If the pattern has the same skeleton as
136 * an existing pattern, and the override parameter is set, then the previous
137 * value is overriden. Otherwise, the previous value is retained. In either
138 * case, the conflicting status is set and previous vale is stored in
139 * conflicting pattern.
140 * <p>
141 * Note that single-field patterns (like "MMM") are automatically added, and
142 * don't need to be added explicitly!
143 *
144 * @param pattern Input pattern, such as "dd/MMM"
145 * @param override When existing values are to be overridden use true,
146 * otherwise use false.
147 * @param conflictingPattern Previous pattern with the same skeleton.
148 * @param status Output param set to success/failure code on exit,
149 * which must not indicate a failure before the function call.
150 * @return conflicting status. The value could be UDATPG_NO_CONFLICT,
151 * UDATPG_BASE_CONFLICT or UDATPG_CONFLICT.
152 * @stable ICU 3.8
153 * <p>
154 * <h4>Sample code</h4>
155 * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample1
156 * \snippet samples/dtptngsample/dtptngsample.cpp addPatternExample
157 * <p>
158 */
159 UDateTimePatternConflict addPattern(const UnicodeString& pattern,
160 UBool override,
161 UnicodeString& conflictingPattern,
162 UErrorCode& status);
163
164 /**
165 * An AppendItem format is a pattern used to append a field if there is no
166 * good match. For example, suppose that the input skeleton is "GyyyyMMMd",
167 * and there is no matching pattern internally, but there is a pattern
168 * matching "yyyyMMMd", say "d-MM-yyyy". Then that pattern is used, plus the
169 * G. The way these two are conjoined is by using the AppendItemFormat for G
170 * (era). So if that value is, say "{0}, {1}" then the final resulting
171 * pattern is "d-MM-yyyy, G".
172 * <p>
173 * There are actually three available variables: {0} is the pattern so far,
174 * {1} is the element we are adding, and {2} is the name of the element.
175 * <p>
176 * This reflects the way that the CLDR data is organized.
177 *
178 * @param field such as UDATPG_ERA_FIELD.
179 * @param value pattern, such as "{0}, {1}"
180 * @stable ICU 3.8
181 */
182 void setAppendItemFormat(UDateTimePatternField field, const UnicodeString& value);
183
184 /**
185 * Getter corresponding to setAppendItemFormat. Values below 0 or at or
186 * above UDATPG_FIELD_COUNT are illegal arguments.
187 *
188 * @param field such as UDATPG_ERA_FIELD.
189 * @return append pattern for field
190 * @stable ICU 3.8
191 */
192 const UnicodeString& getAppendItemFormat(UDateTimePatternField field) const;
193
194 /**
195 * Sets the names of field, eg "era" in English for ERA. These are only
196 * used if the corresponding AppendItemFormat is used, and if it contains a
197 * {2} variable.
198 * <p>
199 * This reflects the way that the CLDR data is organized.
200 *
201 * @param field such as UDATPG_ERA_FIELD.
202 * @param value name of the field
203 * @stable ICU 3.8
204 */
205 void setAppendItemName(UDateTimePatternField field, const UnicodeString& value);
206
207 /**
208 * Getter corresponding to setAppendItemNames. Values below 0 or at or above
209 * UDATPG_FIELD_COUNT are illegal arguments.
210 *
211 * @param field such as UDATPG_ERA_FIELD.
212 * @return name for field
213 * @stable ICU 3.8
214 */
215 const UnicodeString& getAppendItemName(UDateTimePatternField field) const;
216
217 /**
218 * The date time format is a message format pattern used to compose date and
219 * time patterns. The default value is "{0} {1}", where {0} will be replaced
220 * by the date pattern and {1} will be replaced by the time pattern.
221 * <p>
222 * This is used when the input skeleton contains both date and time fields,
223 * but there is not a close match among the added patterns. For example,
224 * suppose that this object was created by adding "dd-MMM" and "hh:mm", and
225 * its datetimeFormat is the default "{0} {1}". Then if the input skeleton
226 * is "MMMdhmm", there is not an exact match, so the input skeleton is
227 * broken up into two components "MMMd" and "hmm". There are close matches
228 * for those two skeletons, so the result is put together with this pattern,
229 * resulting in "d-MMM h:mm".
230 *
231 * @param dateTimeFormat
232 * message format pattern, here {0} will be replaced by the date
233 * pattern and {1} will be replaced by the time pattern.
234 * @stable ICU 3.8
235 */
236 void setDateTimeFormat(const UnicodeString& dateTimeFormat);
237
238 /**
239 * Getter corresponding to setDateTimeFormat.
240 * @return DateTimeFormat.
241 * @stable ICU 3.8
242 */
243 const UnicodeString& getDateTimeFormat() const;
244
245 /**
246 * Return the best pattern matching the input skeleton. It is guaranteed to
247 * have all of the fields in the skeleton.
248 *
249 * @param skeleton
250 * The skeleton is a pattern containing only the variable fields.
251 * For example, "MMMdd" and "mmhh" are skeletons.
252 * @param status Output param set to success/failure code on exit,
253 * which must not indicate a failure before the function call.
254 * @return bestPattern
255 * The best pattern found from the given skeleton.
256 * @stable ICU 3.8
257 * <p>
258 * <h4>Sample code</h4>
259 * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample1
260 * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample
261 * <p>
262 */
263 UnicodeString getBestPattern(const UnicodeString& skeleton, UErrorCode& status);
264
265
266 /**
267 * Return the best pattern matching the input skeleton. It is guaranteed to
268 * have all of the fields in the skeleton.
269 *
270 * @param skeleton
271 * The skeleton is a pattern containing only the variable fields.
272 * For example, "MMMdd" and "mmhh" are skeletons.
273 * @param options
274 * Options for forcing the length of specified fields in the
275 * returned pattern to match those in the skeleton (when this
276 * would not happen otherwise). For default behavior, use
277 * UDATPG_MATCH_NO_OPTIONS.
278 * @param status
279 * Output param set to success/failure code on exit,
280 * which must not indicate a failure before the function call.
281 * @return bestPattern
282 * The best pattern found from the given skeleton.
283 * @stable ICU 4.4
284 */
285 UnicodeString getBestPattern(const UnicodeString& skeleton,
286 UDateTimePatternMatchOptions options,
287 UErrorCode& status);
288
289
290 /**
291 * Adjusts the field types (width and subtype) of a pattern to match what is
292 * in a skeleton. That is, if you supply a pattern like "d-M H:m", and a
293 * skeleton of "MMMMddhhmm", then the input pattern is adjusted to be
294 * "dd-MMMM hh:mm". This is used internally to get the best match for the
295 * input skeleton, but can also be used externally.
296 *
297 * @param pattern Input pattern
298 * @param skeleton
299 * The skeleton is a pattern containing only the variable fields.
300 * For example, "MMMdd" and "mmhh" are skeletons.
301 * @param status Output param set to success/failure code on exit,
302 * which must not indicate a failure before the function call.
303 * @return pattern adjusted to match the skeleton fields widths and subtypes.
304 * @stable ICU 3.8
305 * <p>
306 * <h4>Sample code</h4>
307 * \snippet samples/dtptngsample/dtptngsample.cpp getBestPatternExample1
308 * \snippet samples/dtptngsample/dtptngsample.cpp replaceFieldTypesExample
309 * <p>
310 */
311 UnicodeString replaceFieldTypes(const UnicodeString& pattern,
312 const UnicodeString& skeleton,
313 UErrorCode& status);
314
315 /**
316 * Adjusts the field types (width and subtype) of a pattern to match what is
317 * in a skeleton. That is, if you supply a pattern like "d-M H:m", and a
318 * skeleton of "MMMMddhhmm", then the input pattern is adjusted to be
319 * "dd-MMMM hh:mm". This is used internally to get the best match for the
320 * input skeleton, but can also be used externally.
321 *
322 * @param pattern Input pattern
323 * @param skeleton
324 * The skeleton is a pattern containing only the variable fields.
325 * For example, "MMMdd" and "mmhh" are skeletons.
326 * @param options
327 * Options controlling whether the length of specified fields in the
328 * pattern are adjusted to match those in the skeleton (when this
329 * would not happen otherwise). For default behavior, use
330 * UDATPG_MATCH_NO_OPTIONS.
331 * @param status
332 * Output param set to success/failure code on exit,
333 * which must not indicate a failure before the function call.
334 * @return pattern adjusted to match the skeleton fields widths and subtypes.
335 * @stable ICU 4.4
336 */
337 UnicodeString replaceFieldTypes(const UnicodeString& pattern,
338 const UnicodeString& skeleton,
339 UDateTimePatternMatchOptions options,
340 UErrorCode& status);
341
342 /**
343 * Return a list of all the skeletons (in canonical form) from this class.
344 *
345 * Call getPatternForSkeleton() to get the corresponding pattern.
346 *
347 * @param status Output param set to success/failure code on exit,
348 * which must not indicate a failure before the function call.
349 * @return StringEnumeration with the skeletons.
350 * The caller must delete the object.
351 * @stable ICU 3.8
352 */
353 StringEnumeration* getSkeletons(UErrorCode& status) const;
354
355 /**
356 * Get the pattern corresponding to a given skeleton.
357 * @param skeleton
358 * @return pattern corresponding to a given skeleton.
359 * @stable ICU 3.8
360 */
361 const UnicodeString& getPatternForSkeleton(const UnicodeString& skeleton) const;
362
363 /**
364 * Return a list of all the base skeletons (in canonical form) from this class.
365 *
366 * @param status Output param set to success/failure code on exit,
367 * which must not indicate a failure before the function call.
368 * @return a StringEnumeration with the base skeletons.
369 * The caller must delete the object.
370 * @stable ICU 3.8
371 */
372 StringEnumeration* getBaseSkeletons(UErrorCode& status) const;
373
374 #ifndef U_HIDE_INTERNAL_API
375 /**
376 * Return a list of redundant patterns are those which if removed, make no
377 * difference in the resulting getBestPattern values. This method returns a
378 * list of them, to help check the consistency of the patterns used to build
379 * this generator.
380 *
381 * @param status Output param set to success/failure code on exit,
382 * which must not indicate a failure before the function call.
383 * @return a StringEnumeration with the redundant pattern.
384 * The caller must delete the object.
385 * @internal ICU 3.8
386 */
387 StringEnumeration* getRedundants(UErrorCode& status);
388 #endif /* U_HIDE_INTERNAL_API */
389
390 /**
391 * The decimal value is used in formatting fractions of seconds. If the
392 * skeleton contains fractional seconds, then this is used with the
393 * fractional seconds. For example, suppose that the input pattern is
394 * "hhmmssSSSS", and the best matching pattern internally is "H:mm:ss", and
395 * the decimal string is ",". Then the resulting pattern is modified to be
396 * "H:mm:ss,SSSS"
397 *
398 * @param decimal
399 * @stable ICU 3.8
400 */
401 void setDecimal(const UnicodeString& decimal);
402
403 /**
404 * Getter corresponding to setDecimal.
405 * @return UnicodeString corresponding to the decimal point
406 * @stable ICU 3.8
407 */
408 const UnicodeString& getDecimal() const;
409
410 /**
411 * ICU "poor man's RTTI", returns a UClassID for the actual class.
412 *
413 * @stable ICU 3.8
414 */
415 virtual UClassID getDynamicClassID() const;
416
417 /**
418 * ICU "poor man's RTTI", returns a UClassID for this class.
419 *
420 * @stable ICU 3.8
421 */
422 static UClassID U_EXPORT2 getStaticClassID(void);
423
424 private:
425 /**
426 * Constructor.
427 * @stable ICU 3.8
428 */
429 DateTimePatternGenerator(UErrorCode & status);
430
431 /**
432 * Constructor.
433 * @stable ICU 3.8
434 */
435 DateTimePatternGenerator(const Locale& locale, UErrorCode & status);
436
437 /**
438 * Copy constructor.
439 * @param other DateTimePatternGenerator to copy
440 * @stable ICU 3.8
441 */
442 DateTimePatternGenerator(const DateTimePatternGenerator& other);
443
444 /**
445 * Default assignment operator.
446 * @param other DateTimePatternGenerator to copy
447 * @stable ICU 3.8
448 */
449 DateTimePatternGenerator& operator=(const DateTimePatternGenerator& other);
450
451 Locale pLocale; // pattern locale
452 FormatParser *fp;
453 DateTimeMatcher* dtMatcher;
454 DistanceInfo *distanceInfo;
455 PatternMap *patternMap;
456 UnicodeString appendItemFormats[UDATPG_FIELD_COUNT];
457 UnicodeString appendItemNames[UDATPG_FIELD_COUNT];
458 UnicodeString dateTimeFormat;
459 UnicodeString decimal;
460 DateTimeMatcher *skipMatcher;
461 Hashtable *fAvailableFormatKeyHash;
462 UnicodeString hackPattern;
463 UnicodeString emptyString;
464 UChar fDefaultHourFormatChar;
465
466 /* internal flags masks for adjustFieldTypes etc. */
467 enum {
468 kDTPGNoFlags = 0,
469 kDTPGFixFractionalSeconds = 1,
470 kDTPGSkeletonUsesCapJ = 2
471 };
472
473 void initData(const Locale &locale, UErrorCode &status);
474 void addCanonicalItems();
475 void addICUPatterns(const Locale& locale, UErrorCode& status);
476 void hackTimes(const UnicodeString& hackPattern, UErrorCode& status);
477 void addCLDRData(const Locale& locale, UErrorCode& status);
478 UDateTimePatternConflict addPatternWithSkeleton(const UnicodeString& pattern, const UnicodeString * skeletonToUse, UBool override, UnicodeString& conflictingPattern, UErrorCode& status);
479 void initHashtable(UErrorCode& status);
480 void setDateTimeFromCalendar(const Locale& locale, UErrorCode& status);
481 void setDecimalSymbols(const Locale& locale, UErrorCode& status);
482 UDateTimePatternField getAppendFormatNumber(const char* field) const;
483 UDateTimePatternField getAppendNameNumber(const char* field) const;
484 void getAppendName(UDateTimePatternField field, UnicodeString& value);
485 int32_t getCanonicalIndex(const UnicodeString& field);
486 const UnicodeString* getBestRaw(DateTimeMatcher& source, int32_t includeMask, DistanceInfo* missingFields, const PtnSkeleton** specifiedSkeletonPtr = 0);
487 UnicodeString adjustFieldTypes(const UnicodeString& pattern, const PtnSkeleton* specifiedSkeleton, int32_t flags, UDateTimePatternMatchOptions options = UDATPG_MATCH_NO_OPTIONS);
488 UnicodeString getBestAppending(int32_t missingFields, int32_t flags, UDateTimePatternMatchOptions options = UDATPG_MATCH_NO_OPTIONS);
489 int32_t getTopBitNumber(int32_t foundMask);
490 void setAvailableFormat(const UnicodeString &key, UErrorCode& status);
491 UBool isAvailableFormatSet(const UnicodeString &key) const;
492 void copyHashtable(Hashtable *other, UErrorCode &status);
493 UBool isCanonicalItem(const UnicodeString& item) const;
494 } ;// end class DateTimePatternGenerator
495
496 U_NAMESPACE_END
497
498 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial