← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/icu/source/i18n/unicode/dtitvfmt.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/icu/source/i18n/unicode/dtitvfmt.h
1
 
/********************************************************************************
2
 
* Copyright (C) 2008-2010, International Business Machines Corporation and
3
 
* others. All Rights Reserved.
4
 
*******************************************************************************
5
 
*
6
 
* File DTITVFMT.H
7
 
*
8
 
*******************************************************************************
9
 
*/
10
 
 
11
 
#ifndef __DTITVFMT_H__
12
 
#define __DTITVFMT_H__
13
 
 
14
 
 
15
 
#include "unicode/utypes.h"
16
 
 
17
 
/**
18
 
 * \file
19
 
 * \brief C++ API: Format and parse date interval in a language-independent manner.
20
 
 */
21
 
 
22
 
#if !UCONFIG_NO_FORMATTING
23
 
 
24
 
#include "unicode/ucal.h"
25
 
#include "unicode/smpdtfmt.h"
26
 
#include "unicode/dtintrv.h"
27
 
#include "unicode/dtitvinf.h"
28
 
#include "unicode/dtptngen.h"
29
 
 
30
 
U_NAMESPACE_BEGIN
31
 
 
32
 
 
33
 
 
34
 
/**
35
 
 * DateIntervalFormat is a class for formatting and parsing date
36
 
 * intervals in a language-independent manner.
37
 
 * Only formatting is supported, parsing is not supported.
38
 
 *
39
 
 * <P>
40
 
 * Date interval means from one date to another date,
41
 
 * for example, from "Jan 11, 2008" to "Jan 18, 2008".
42
 
 * We introduced class DateInterval to represent it.
43
 
 * DateInterval is a pair of UDate, which is
44
 
 * the standard milliseconds since 24:00 GMT, Jan 1, 1970.
45
 
 *
46
 
 * <P>
47
 
 * DateIntervalFormat formats a DateInterval into
48
 
 * text as compactly as possible.
49
 
 * For example, the date interval format from "Jan 11, 2008" to "Jan 18,. 2008"
50
 
 * is "Jan 11-18, 2008" for English.
51
 
 * And it parses text into DateInterval,
52
 
 * although initially, parsing is not supported.
53
 
 *
54
 
 * <P>
55
 
 * There is no structural information in date time patterns.
56
 
 * For any punctuations and string literals inside a date time pattern,
57
 
 * we do not know whether it is just a separator, or a prefix, or a suffix.
58
 
 * Without such information, so, it is difficult to generate a sub-pattern
59
 
 * (or super-pattern) by algorithm.
60
 
 * So, formatting a DateInterval is pattern-driven. It is very
61
 
 * similar to formatting in SimpleDateFormat.
62
 
 * We introduce class DateIntervalInfo to save date interval
63
 
 * patterns, similar to date time pattern in SimpleDateFormat.
64
 
 *
65
 
 * <P>
66
 
 * Logically, the interval patterns are mappings
67
 
 * from (skeleton, the_largest_different_calendar_field)
68
 
 * to (date_interval_pattern).
69
 
 *
70
 
 * <P>
71
 
 * A skeleton
72
 
 * <ol>
73
 
 * <li>
74
 
 * only keeps the field pattern letter and ignores all other parts
75
 
 * in a pattern, such as space, punctuations, and string literals.
76
 
 * </li>
77
 
 * <li>
78
 
 * hides the order of fields.
79
 
 * </li>
80
 
 * <li>
81
 
 * might hide a field's pattern letter length.
82
 
 * </li>
83
 
 * </ol>
84
 
 *
85
 
 * For those non-digit calendar fields, the pattern letter length is
86
 
 * important, such as MMM, MMMM, and MMMMM; EEE and EEEE,
87
 
 * and the field's pattern letter length is honored.
88
 
 *
89
 
 * For the digit calendar fields,  such as M or MM, d or dd, yy or yyyy,
90
 
 * the field pattern length is ignored and the best match, which is defined
91
 
 * in date time patterns, will be returned without honor the field pattern
92
 
 * letter length in skeleton.
93
 
 *
94
 
 * <P>
95
 
 * The calendar fields we support for interval formatting are:
96
 
 * year, month, date, day-of-week, am-pm, hour, hour-of-day, and minute.
97
 
 * Those calendar fields can be defined in the following order:
98
 
 * year >  month > date > hour (in day) >  minute
99
 
 *
100
 
 * The largest different calendar fields between 2 calendars is the
101
 
 * first different calendar field in above order.
102
 
 *
103
 
 * For example: the largest different calendar fields between "Jan 10, 2007"
104
 
 * and "Feb 20, 2008" is year.
105
 
 *
106
 
 * <P>
107
 
 * For other calendar fields, the compact interval formatting is not
108
 
 * supported. And the interval format will be fall back to fall-back
109
 
 * patterns, which is mostly "{date0} - {date1}".
110
 
 *
111
 
 * <P>
112
 
 * There is a set of pre-defined static skeleton strings.
113
 
 * There are pre-defined interval patterns for those pre-defined skeletons
114
 
 * in locales' resource files.
115
 
 * For example, for a skeleton UDAT_YEAR_ABBR_MONTH_DAY, which is  &quot;yMMMd&quot;,
116
 
 * in  en_US, if the largest different calendar field between date1 and date2
117
 
 * is &quot;year&quot;, the date interval pattern  is &quot;MMM d, yyyy - MMM d, yyyy&quot;,
118
 
 * such as &quot;Jan 10, 2007 - Jan 10, 2008&quot;.
119
 
 * If the largest different calendar field between date1 and date2 is &quot;month&quot;,
120
 
 * the date interval pattern is &quot;MMM d - MMM d, yyyy&quot;,
121
 
 * such as &quot;Jan 10 - Feb 10, 2007&quot;.
122
 
 * If the largest different calendar field between date1 and date2 is &quot;day&quot;,
123
 
 * the date interval pattern is &quot;MMM d-d, yyyy&quot;, such as &quot;Jan 10-20, 2007&quot;.
124
 
 *
125
 
 * For date skeleton, the interval patterns when year, or month, or date is
126
 
 * different are defined in resource files.
127
 
 * For time skeleton, the interval patterns when am/pm, or hour, or minute is
128
 
 * different are defined in resource files.
129
 
 *
130
 
 * <P>
131
 
 * If a skeleton is not found in a locale's DateIntervalInfo, which means
132
 
 * the interval patterns for the skeleton is not defined in resource file,
133
 
 * the interval pattern will falls back to the interval "fallback" pattern
134
 
 * defined in resource file.
135
 
 * If the interval "fallback" pattern is not defined, the default fall-back
136
 
 * is "{date0} - {data1}".
137
 
 *
138
 
 * <P>
139
 
 * For the combination of date and time,
140
 
 * The rule to generate interval patterns are:
141
 
 * <ol>
142
 
 * <li>
143
 
 *    when the year, month, or day differs, falls back to fall-back
144
 
 *    interval pattern, which mostly is the concatenate the two original
145
 
 *    expressions with a separator between,
146
 
 *    For example, interval pattern from "Jan 10, 2007 10:10 am"
147
 
 *    to "Jan 11, 2007 10:10am" is
148
 
 *    "Jan 10, 2007 10:10 am - Jan 11, 2007 10:10am"
149
 
 * </li>
150
 
 * <li>
151
 
 *    otherwise, present the date followed by the range expression
152
 
 *    for the time.
153
 
 *    For example, interval pattern from "Jan 10, 2007 10:10 am"
154
 
 *    to "Jan 10, 2007 11:10am" is "Jan 10, 2007 10:10 am - 11:10am"
155
 
 * </li>
156
 
 * </ol>
157
 
 *
158
 
 *
159
 
 * <P>
160
 
 * If two dates are the same, the interval pattern is the single date pattern.
161
 
 * For example, interval pattern from "Jan 10, 2007" to "Jan 10, 2007" is
162
 
 * "Jan 10, 2007".
163
 
 *
164
 
 * Or if the presenting fields between 2 dates have the exact same values,
165
 
 * the interval pattern is the  single date pattern.
166
 
 * For example, if user only requests year and month,
167
 
 * the interval pattern from "Jan 10, 2007" to "Jan 20, 2007" is "Jan 2007".
168
 
 *
169
 
 * <P>
170
 
 * DateIntervalFormat needs the following information for correct
171
 
 * formatting: time zone, calendar type, pattern, date format symbols,
172
 
 * and date interval patterns.
173
 
 * It can be instantiated in 2 ways:
174
 
 * <ol>
175
 
 * <li>
176
 
 *    create an instance using default or given locale plus given skeleton.
177
 
 *    Users are encouraged to created date interval formatter this way and
178
 
 *    to use the pre-defined skeleton macros, such as
179
 
 *    UDAT_YEAR_NUM_MONTH, which consists the calendar fields and
180
 
 *    the format style.
181
 
 * </li>
182
 
 * <li>
183
 
 *    create an instance using default or given locale plus given skeleton
184
 
 *    plus a given DateIntervalInfo.
185
 
 *    This factory method is for powerful users who want to provide their own
186
 
 *    interval patterns.
187
 
 *    Locale provides the timezone, calendar, and format symbols information.
188
 
 *    Local plus skeleton provides full pattern information.
189
 
 *    DateIntervalInfo provides the date interval patterns.
190
 
 * </li>
191
 
 * </ol>
192
 
 *
193
 
 * <P>
194
 
 * For the calendar field pattern letter, such as G, y, M, d, a, h, H, m, s etc.
195
 
 * DateIntervalFormat uses the same syntax as that of
196
 
 * DateTime format.
197
 
 *
198
 
 * <P>
199
 
 * Code Sample: general usage
200
 
 * <pre>
201
 
 * \code
202
 
 *   // the date interval object which the DateIntervalFormat formats on
203
 
 *   // and parses into
204
 
 *   DateInterval*  dtInterval = new DateInterval(1000*3600*24, 1000*3600*24*2);
205
 
 *   UErrorCode status = U_ZERO_ERROR;
206
 
 *   DateIntervalFormat* dtIntervalFmt = DateIntervalFormat::createInstance(
207
 
 *                           UDAT_YEAR_MONTH_DAY,
208
 
 *                           Locale("en", "GB", ""), status);
209
 
 *   UnicodeUnicodeString dateIntervalString;
210
 
 *   FieldPosition pos = 0;
211
 
 *   // formatting
212
 
 *   dtIntervalFmt->format(dtInterval, dateIntervalUnicodeString, pos, status);
213
 
 *   delete dtIntervalFmt;
214
 
 * \endcode
215
 
 * </pre>
216
 
 */
217
 
 
218
 
class U_I18N_API DateIntervalFormat : public Format {
219
 
public:
220
 
 
221
 
    /**
222
 
     * Construct a DateIntervalFormat from skeleton and  the default locale.
223
 
     *
224
 
     * This is a convenient override of
225
 
     * createInstance(const UnicodeString& skeleton, const Locale& locale,
226
 
     *                UErrorCode&)
227
 
     * with the value of locale as default locale.
228
 
     *
229
 
     * @param skeleton  the skeleton on which interval format based.
230
 
     * @param status    output param set to success/failure code on exit
231
 
     * @return          a date time interval formatter which the caller owns.
232
 
     * @stable ICU 4.0
233
 
     */
234
 
    static DateIntervalFormat* U_EXPORT2 createInstance(
235
 
                                               const UnicodeString& skeleton,
236
 
                                               UErrorCode& status);
237
 
 
238
 
    /**
239
 
     * Construct a DateIntervalFormat from skeleton and a given locale.
240
 
     * <P>
241
 
     * In this factory method,
242
 
     * the date interval pattern information is load from resource files.
243
 
     * Users are encouraged to created date interval formatter this way and
244
 
     * to use the pre-defined skeleton macros.
245
 
     *
246
 
     * <P>
247
 
     * There are pre-defined skeletons (defined in udate.h) having predefined
248
 
     * interval patterns in resource files.
249
 
     * Users are encouraged to use those macros.
250
 
     * For example:
251
 
     * DateIntervalFormat::createInstance(UDAT_MONTH_DAY, status)
252
 
     *
253
 
     * The given Locale provides the interval patterns.
254
 
     * For example, for en_GB, if skeleton is UDAT_YEAR_ABBR_MONTH_WEEKDAY_DAY,
255
 
     * which is "yMMMEEEd",
256
 
     * the interval patterns defined in resource file to above skeleton are:
257
 
     * "EEE, d MMM, yyyy - EEE, d MMM, yyyy" for year differs,
258
 
     * "EEE, d MMM - EEE, d MMM, yyyy" for month differs,
259
 
     * "EEE, d - EEE, d MMM, yyyy" for day differs,
260
 
     * @param skeleton  the skeleton on which interval format based.
261
 
     * @param locale    the given locale
262
 
     * @param status    output param set to success/failure code on exit
263
 
     * @return          a date time interval formatter which the caller owns.
264
 
     * @stable ICU 4.0
265
 
     */
266
 
 
267
 
    static DateIntervalFormat* U_EXPORT2 createInstance(
268
 
                                               const UnicodeString& skeleton,
269
 
                                               const Locale& locale,
270
 
                                               UErrorCode& status);
271
 
 
272
 
    /**
273
 
     * Construct a DateIntervalFormat from skeleton
274
 
     *  DateIntervalInfo, and default locale.
275
 
     *
276
 
     * This is a convenient override of
277
 
     * createInstance(const UnicodeString& skeleton, const Locale& locale,
278
 
     *                const DateIntervalInfo& dtitvinf, UErrorCode&)
279
 
     * with the locale value as default locale.
280
 
     *
281
 
     * @param skeleton  the skeleton on which interval format based.
282
 
     * @param dtitvinf  the DateIntervalInfo object.
283
 
     * @param status    output param set to success/failure code on exit
284
 
     * @return          a date time interval formatter which the caller owns.
285
 
     * @stable ICU 4.0
286
 
     */
287
 
    static DateIntervalFormat* U_EXPORT2 createInstance(
288
 
                                              const UnicodeString& skeleton,
289
 
                                              const DateIntervalInfo& dtitvinf,
290
 
                                              UErrorCode& status);
291
 
 
292
 
    /**
293
 
     * Construct a DateIntervalFormat from skeleton
294
 
     * a DateIntervalInfo, and the given locale.
295
 
     *
296
 
     * <P>
297
 
     * In this factory method, user provides its own date interval pattern
298
 
     * information, instead of using those pre-defined data in resource file.
299
 
     * This factory method is for powerful users who want to provide their own
300
 
     * interval patterns.
301
 
     * <P>
302
 
     * There are pre-defined skeletons (defined in udate.h) having predefined
303
 
     * interval patterns in resource files.
304
 
     * Users are encouraged to use those macros.
305
 
     * For example:
306
 
     * DateIntervalFormat::createInstance(UDAT_MONTH_DAY, status)
307
 
     *
308
 
     * The DateIntervalInfo provides the interval patterns.
309
 
     * and the DateIntervalInfo ownership remains to the caller.
310
 
     *
311
 
     * User are encouraged to set default interval pattern in DateIntervalInfo
312
 
     * as well, if they want to set other interval patterns ( instead of
313
 
     * reading the interval patterns from resource files).
314
 
     * When the corresponding interval pattern for a largest calendar different
315
 
     * field is not found ( if user not set it ), interval format fallback to
316
 
     * the default interval pattern.
317
 
     * If user does not provide default interval pattern, it fallback to
318
 
     * "{date0} - {date1}"
319
 
     *
320
 
     * @param skeleton  the skeleton on which interval format based.
321
 
     * @param locale    the given locale
322
 
     * @param dtitvinf  the DateIntervalInfo object.
323
 
     * @param status    output param set to success/failure code on exit
324
 
     * @return          a date time interval formatter which the caller owns.
325
 
     * @stable ICU 4.0
326
 
     */
327
 
    static DateIntervalFormat* U_EXPORT2 createInstance(
328
 
                                              const UnicodeString& skeleton,
329
 
                                              const Locale& locale,
330
 
                                              const DateIntervalInfo& dtitvinf,
331
 
                                              UErrorCode& status);
332
 
 
333
 
    /**
334
 
     * Destructor.
335
 
     * @stable ICU 4.0
336
 
     */
337
 
    virtual ~DateIntervalFormat();
338
 
 
339
 
    /**
340
 
     * Clone this Format object polymorphically. The caller owns the result and
341
 
     * should delete it when done.
342
 
     * @return    A copy of the object.
343
 
     * @stable ICU 4.0
344
 
     */
345
 
    virtual Format* clone(void) const;
346
 
 
347
 
    /**
348
 
     * Return true if the given Format objects are semantically equal. Objects
349
 
     * of different subclasses are considered unequal.
350
 
     * @param other    the object to be compared with.
351
 
     * @return         true if the given Format objects are semantically equal.
352
 
     * @stable ICU 4.0
353
 
     */
354
 
    virtual UBool operator==(const Format& other) const;
355
 
 
356
 
    /**
357
 
     * Return true if the given Format objects are not semantically equal.
358
 
     * Objects of different subclasses are considered unequal.
359
 
     * @param other the object to be compared with.
360
 
     * @return      true if the given Format objects are not semantically equal.
361
 
     * @stable ICU 4.0
362
 
     */
363
 
    UBool operator!=(const Format& other) const;
364
 
 
365
 
 
366
 
    using Format::format;
367
 
 
368
 
    /**
369
 
     * Format an object to produce a string. This method handles Formattable
370
 
     * objects with a DateInterval type.
371
 
     * If a the Formattable object type is not a DateInterval,
372
 
     * then it returns a failing UErrorCode.
373
 
     *
374
 
     * @param obj               The object to format.
375
 
     *                          Must be a DateInterval.
376
 
     * @param appendTo          Output parameter to receive result.
377
 
     *                          Result is appended to existing contents.
378
 
     * @param fieldPosition     On input: an alignment field, if desired.
379
 
     *                          On output: the offsets of the alignment field.
380
 
     * @param status            Output param filled with success/failure status.
381
 
     * @return                  Reference to 'appendTo' parameter.
382
 
     * @stable ICU 4.0
383
 
     */
384
 
    virtual UnicodeString& format(const Formattable& obj,
385
 
                                  UnicodeString& appendTo,
386
 
                                  FieldPosition& fieldPosition,
387
 
                                  UErrorCode& status) const ;
388
 
 
389
 
 
390
 
 
391
 
    /**
392
 
     * Format a DateInterval to produce a string.
393
 
     *
394
 
     * @param dtInterval        DateInterval to be formatted.
395
 
     * @param appendTo          Output parameter to receive result.
396
 
     *                          Result is appended to existing contents.
397
 
     * @param fieldPosition     On input: an alignment field, if desired.
398
 
     *                          On output: the offsets of the alignment field.
399
 
     * @param status            Output param filled with success/failure status.
400
 
     * @return                  Reference to 'appendTo' parameter.
401
 
     * @stable ICU 4.0
402
 
     */
403
 
    UnicodeString& format(const DateInterval* dtInterval,
404
 
                          UnicodeString& appendTo,
405
 
                          FieldPosition& fieldPosition,
406
 
                          UErrorCode& status) const ;
407
 
 
408
 
 
409
 
    /**
410
 
     * Format 2 Calendars to produce a string.
411
 
     *
412
 
     * Note: "fromCalendar" and "toCalendar" are not const,
413
 
     * since calendar is not const in  SimpleDateFormat::format(Calendar&),
414
 
     *
415
 
     * @param fromCalendar      calendar set to the from date in date interval
416
 
     *                          to be formatted into date interval string
417
 
     * @param toCalendar        calendar set to the to date in date interval
418
 
     *                          to be formatted into date interval string
419
 
     * @param appendTo          Output parameter to receive result.
420
 
     *                          Result is appended to existing contents.
421
 
     * @param fieldPosition     On input: an alignment field, if desired.
422
 
     *                          On output: the offsets of the alignment field.
423
 
     * @param status            Output param filled with success/failure status.
424
 
     *                          Caller needs to make sure it is SUCCESS
425
 
     *                          at the function entrance
426
 
     * @return                  Reference to 'appendTo' parameter.
427
 
     * @stable ICU 4.0
428
 
     */
429
 
    UnicodeString& format(Calendar& fromCalendar,
430
 
                          Calendar& toCalendar,
431
 
                          UnicodeString& appendTo,
432
 
                          FieldPosition& fieldPosition,
433
 
                          UErrorCode& status) const ;
434
 
 
435
 
    /**
436
 
     * Date interval parsing is not supported. Please do not use.
437
 
     * <P>
438
 
     * This method should handle parsing of
439
 
     * date time interval strings into Formattable objects with
440
 
     * DateInterval type, which is a pair of UDate.
441
 
     * <P>
442
 
     * Before calling, set parse_pos.index to the offset you want to start
443
 
     * parsing at in the source. After calling, parse_pos.index is the end of
444
 
     * the text you parsed. If error occurs, index is unchanged.
445
 
     * <P>
446
 
     * When parsing, leading whitespace is discarded (with a successful parse),
447
 
     * while trailing whitespace is left as is.
448
 
     * <P>
449
 
     * See Format::parseObject() for more.
450
 
     *
451
 
     * @param source    The string to be parsed into an object.
452
 
     * @param result    Formattable to be set to the parse result.
453
 
     *                  If parse fails, return contents are undefined.
454
 
     * @param parse_pos The position to start parsing at. Since no parsing
455
 
     *                  is supported, upon return this param is unchanged.
456
 
     * @return          A newly created Formattable* object, or NULL
457
 
     *                  on failure.  The caller owns this and should
458
 
     *                  delete it when done.
459
 
     * @internal ICU 4.0
460
 
     */
461
 
    virtual void parseObject(const UnicodeString& source,
462
 
                             Formattable& result,
463
 
                             ParsePosition& parse_pos) const;
464
 
 
465
 
 
466
 
    /**
467
 
     * Gets the date time interval patterns.
468
 
     * @return the date time interval patterns associated with
469
 
     * this date interval formatter.
470
 
     * @stable ICU 4.0
471
 
     */
472
 
    const DateIntervalInfo* getDateIntervalInfo(void) const;
473
 
 
474
 
 
475
 
    /**
476
 
     * Set the date time interval patterns.
477
 
     * @param newIntervalPatterns   the given interval patterns to copy.
478
 
     * @param status          output param set to success/failure code on exit
479
 
     * @stable ICU 4.0
480
 
     */
481
 
    void setDateIntervalInfo(const DateIntervalInfo& newIntervalPatterns,
482
 
                             UErrorCode& status);
483
 
 
484
 
 
485
 
    /**
486
 
     * Gets the date formatter
487
 
     * @return the date formatter associated with this date interval formatter.
488
 
     * @stable ICU 4.0
489
 
     */
490
 
    const DateFormat* getDateFormat(void) const;
491
 
 
492
 
    /**
493
 
     * Return the class ID for this class. This is useful only for comparing to
494
 
     * a return value from getDynamicClassID(). For example:
495
 
     * <pre>
496
 
     * .   Base* polymorphic_pointer = createPolymorphicObject();
497
 
     * .   if (polymorphic_pointer->getDynamicClassID() ==
498
 
     * .       erived::getStaticClassID()) ...
499
 
     * </pre>
500
 
     * @return          The class ID for all objects of this class.
501
 
     * @stable ICU 4.0
502
 
     */
503
 
    static UClassID U_EXPORT2 getStaticClassID(void);
504
 
 
505
 
    /**
506
 
     * Returns a unique class ID POLYMORPHICALLY. Pure virtual override. This
507
 
     * method is to implement a simple version of RTTI, since not all C++
508
 
     * compilers support genuine RTTI. Polymorphic operator==() and clone()
509
 
     * methods call this method.
510
 
     *
511
 
     * @return          The class ID for this object. All objects of a
512
 
     *                  given class have the same class ID.  Objects of
513
 
     *                  other classes have different class IDs.
514
 
     * @stable ICU 4.0
515
 
     */
516
 
    virtual UClassID getDynamicClassID(void) const;
517
 
 
518
 
protected:
519
 
 
520
 
    /**
521
 
     * Copy constructor.
522
 
     * @stable ICU 4.0
523
 
     */
524
 
    DateIntervalFormat(const DateIntervalFormat&);
525
 
 
526
 
    /**
527
 
     * Assignment operator.
528
 
     * @stable ICU 4.0
529
 
     */
530
 
    DateIntervalFormat& operator=(const DateIntervalFormat&);
531
 
 
532
 
private:
533
 
 
534
 
    /*
535
 
     * This is for ICU internal use only. Please do not use.
536
 
     * Save the interval pattern information.
537
 
     * Interval pattern consists of 2 single date patterns and the separator.
538
 
     * For example, interval pattern "MMM d - MMM d, yyyy" consists
539
 
     * a single date pattern "MMM d", another single date pattern "MMM d, yyyy",
540
 
     * and a separator "-".
541
 
     * The pattern is divided into 2 parts. For above example,
542
 
     * the first part is "MMM d - ", and the second part is "MMM d, yyyy".
543
 
     * Also, the first date appears in an interval pattern could be
544
 
     * the earlier date or the later date.
545
 
     * And such information is saved in the interval pattern as well.
546
 
     * @internal ICU 4.0
547
 
     */
548
 
    struct PatternInfo {
549
 
        UnicodeString firstPart;
550
 
        UnicodeString secondPart;
551
 
        /**
552
 
         * Whether the first date in interval pattern is later date or not.
553
 
         * Fallback format set the default ordering.
554
 
         * And for a particular interval pattern, the order can be
555
 
         * overriden by prefixing the interval pattern with "latestFirst:" or
556
 
         * "earliestFirst:"
557
 
         * For example, given 2 date, Jan 10, 2007 to Feb 10, 2007.
558
 
         * if the fallback format is "{0} - {1}",
559
 
         * and the pattern is "d MMM - d MMM yyyy", the interval format is
560
 
         * "10 Jan - 10 Feb, 2007".
561
 
         * If the pattern is "latestFirst:d MMM - d MMM yyyy",
562
 
         * the interval format is "10 Feb - 10 Jan, 2007"
563
 
         */
564
 
        UBool         laterDateFirst;
565
 
    };
566
 
 
567
 
 
568
 
    /**
569
 
     * default constructor
570
 
     * @internal ICU 4.0
571
 
     */
572
 
    DateIntervalFormat();
573
 
 
574
 
    /**
575
 
     * Construct a DateIntervalFormat from DateFormat,
576
 
     * a DateIntervalInfo, and skeleton.
577
 
     * DateFormat provides the timezone, calendar,
578
 
     * full pattern, and date format symbols information.
579
 
     * It should be a SimpleDateFormat object which
580
 
     * has a pattern in it.
581
 
     * the DateIntervalInfo provides the interval patterns.
582
 
     *
583
 
     * Note: the DateIntervalFormat takes ownership of both
584
 
     * DateFormat and DateIntervalInfo objects.
585
 
     * Caller should not delete them.
586
 
     *
587
 
     * @param locale    the locale of this date interval formatter.
588
 
     * @param dtitvinf  the DateIntervalInfo object to be adopted.
589
 
     * @param skeleton  the skeleton of the date formatter
590
 
     * @param status    output param set to success/failure code on exit
591
 
     * @internal ICU 4.0
592
 
     */
593
 
    DateIntervalFormat(const Locale& locale, DateIntervalInfo* dtItvInfo,
594
 
                       const UnicodeString* skeleton, UErrorCode& status);
595
 
 
596
 
 
597
 
    /**
598
 
     * Construct a DateIntervalFormat from DateFormat
599
 
     * and a DateIntervalInfo.
600
 
     *
601
 
     * It is a wrapper of the constructor.
602
 
     *
603
 
     * @param locale    the locale of this date interval formatter.
604
 
     * @param dtitvinf  the DateIntervalInfo object to be adopted.
605
 
     * @param skeleton  the skeleton of this formatter.
606
 
     * @param status    Output param set to success/failure code.
607
 
     * @return          a date time interval formatter which the caller owns.
608
 
     * @internal ICU 4.0
609
 
     */
610
 
    static DateIntervalFormat* U_EXPORT2 create(const Locale& locale,
611
 
                                                DateIntervalInfo* dtitvinf,
612
 
                                                const UnicodeString* skeleton,
613
 
                                                UErrorCode& status);
614
 
 
615
 
    /**
616
 
     * Create a simple date/time formatter from skeleton, given locale,
617
 
     * and date time pattern generator.
618
 
     *
619
 
     * @param skeleton  the skeleton on which date format based.
620
 
     * @param locale    the given locale.
621
 
     * @param dtpng     the date time pattern generator.
622
 
     * @param status    Output param to be set to success/failure code.
623
 
     *                  If it is failure, the returned date formatter will
624
 
     *                  be NULL.
625
 
     * @return          a simple date formatter which the caller owns.
626
 
     * @internal ICU 4.0
627
 
     */
628
 
    static SimpleDateFormat* U_EXPORT2 createSDFPatternInstance(
629
 
                                        const UnicodeString& skeleton,
630
 
                                        const Locale& locale,
631
 
                                        DateTimePatternGenerator* dtpng,
632
 
                                        UErrorCode& status);
633
 
 
634
 
 
635
 
    /**
636
 
     *  Below are for generating interval patterns local to the formatter
637
 
     */
638
 
 
639
 
 
640
 
    /**
641
 
     * Format 2 Calendars using fall-back interval pattern
642
 
     *
643
 
     * The full pattern used in this fall-back format is the
644
 
     * full pattern of the date formatter.
645
 
     *
646
 
     * @param fromCalendar      calendar set to the from date in date interval
647
 
     *                          to be formatted into date interval string
648
 
     * @param toCalendar        calendar set to the to date in date interval
649
 
     *                          to be formatted into date interval string
650
 
     * @param appendTo          Output parameter to receive result.
651
 
     *                          Result is appended to existing contents.
652
 
     * @param pos               On input: an alignment field, if desired.
653
 
     *                          On output: the offsets of the alignment field.
654
 
     * @param status            output param set to success/failure code on exit
655
 
     * @return                  Reference to 'appendTo' parameter.
656
 
     * @internal ICU 4.0
657
 
     */
658
 
    UnicodeString& fallbackFormat(Calendar& fromCalendar,
659
 
                                  Calendar& toCalendar,
660
 
                                  UnicodeString& appendTo,
661
 
                                  FieldPosition& pos,
662
 
                                  UErrorCode& status) const;
663
 
 
664
 
 
665
 
 
666
 
    /**
667
 
     * Initialize interval patterns locale to this formatter
668
 
     *
669
 
     * This code is a bit complicated since
670
 
     * 1. the interval patterns saved in resource bundle files are interval
671
 
     *    patterns based on date or time only.
672
 
     *    It does not have interval patterns based on both date and time.
673
 
     *    Interval patterns on both date and time are algorithm generated.
674
 
     *
675
 
     *    For example, it has interval patterns on skeleton "dMy" and "hm",
676
 
     *    but it does not have interval patterns on skeleton "dMyhm".
677
 
     *
678
 
     *    The rule to generate interval patterns for both date and time skeleton are
679
 
     *    1) when the year, month, or day differs, concatenate the two original
680
 
     *    expressions with a separator between,
681
 
     *    For example, interval pattern from "Jan 10, 2007 10:10 am"
682
 
     *    to "Jan 11, 2007 10:10am" is
683
 
     *    "Jan 10, 2007 10:10 am - Jan 11, 2007 10:10am"
684
 
     *
685
 
     *    2) otherwise, present the date followed by the range expression
686
 
     *    for the time.
687
 
     *    For example, interval pattern from "Jan 10, 2007 10:10 am"
688
 
     *    to "Jan 10, 2007 11:10am" is
689
 
     *    "Jan 10, 2007 10:10 am - 11:10am"
690
 
     *
691
 
     * 2. even a pattern does not request a certain calendar field,
692
 
     *    the interval pattern needs to include such field if such fields are
693
 
     *    different between 2 dates.
694
 
     *    For example, a pattern/skeleton is "hm", but the interval pattern
695
 
     *    includes year, month, and date when year, month, and date differs.
696
 
     *
697
 
     *
698
 
     * @param status    output param set to success/failure code on exit
699
 
     * @internal ICU 4.0
700
 
     */
701
 
    void initializePattern(UErrorCode& status);
702
 
 
703
 
 
704
 
 
705
 
    /**
706
 
     * Set fall back interval pattern given a calendar field,
707
 
     * a skeleton, and a date time pattern generator.
708
 
     * @param field      the largest different calendar field
709
 
     * @param skeleton   a skeleton
710
 
     * @param status     output param set to success/failure code on exit
711
 
     * @internal ICU 4.0
712
 
     */
713
 
    void setFallbackPattern(UCalendarDateFields field,
714
 
                            const UnicodeString& skeleton,
715
 
                            UErrorCode& status);
716
 
 
717
 
 
718
 
 
719
 
    /**
720
 
     * get separated date and time skeleton from a combined skeleton.
721
 
     *
722
 
     * The difference between date skeleton and normalizedDateSkeleton are:
723
 
     * 1. both 'y' and 'd' are appeared only once in normalizeDateSkeleton
724
 
     * 2. 'E' and 'EE' are normalized into 'EEE'
725
 
     * 3. 'MM' is normalized into 'M'
726
 
     *
727
 
     ** the difference between time skeleton and normalizedTimeSkeleton are:
728
 
     * 1. both 'H' and 'h' are normalized as 'h' in normalized time skeleton,
729
 
     * 2. 'a' is omitted in normalized time skeleton.
730
 
     * 3. there is only one appearance for 'h', 'm','v', 'z' in normalized time
731
 
     *    skeleton
732
 
     *
733
 
     *
734
 
     *  @param skeleton               given combined skeleton.
735
 
     *  @param date                   Output parameter for date only skeleton.
736
 
     *  @param normalizedDate         Output parameter for normalized date only
737
 
     *
738
 
     *  @param time                   Output parameter for time only skeleton.
739
 
     *  @param normalizedTime         Output parameter for normalized time only
740
 
     *                                skeleton.
741
 
     *
742
 
     * @internal ICU 4.0
743
 
     */
744
 
    static void  U_EXPORT2 getDateTimeSkeleton(const UnicodeString& skeleton,
745
 
                                    UnicodeString& date,
746
 
                                    UnicodeString& normalizedDate,
747
 
                                    UnicodeString& time,
748
 
                                    UnicodeString& normalizedTime);
749
 
 
750
 
 
751
 
 
752
 
    /**
753
 
     * Generate date or time interval pattern from resource,
754
 
     * and set them into the interval pattern locale to this formatter.
755
 
     *
756
 
     * It needs to handle the following:
757
 
     * 1. need to adjust field width.
758
 
     *    For example, the interval patterns saved in DateIntervalInfo
759
 
     *    includes "dMMMy", but not "dMMMMy".
760
 
     *    Need to get interval patterns for dMMMMy from dMMMy.
761
 
     *    Another example, the interval patterns saved in DateIntervalInfo
762
 
     *    includes "hmv", but not "hmz".
763
 
     *    Need to get interval patterns for "hmz' from 'hmv'
764
 
     *
765
 
     * 2. there might be no pattern for 'y' differ for skeleton "Md",
766
 
     *    in order to get interval patterns for 'y' differ,
767
 
     *    need to look for it from skeleton 'yMd'
768
 
     *
769
 
     * @param dateSkeleton   normalized date skeleton
770
 
     * @param timeSkeleton   normalized time skeleton
771
 
     * @return               whether the resource is found for the skeleton.
772
 
     *                       TRUE if interval pattern found for the skeleton,
773
 
     *                       FALSE otherwise.
774
 
     * @internal ICU 4.0
775
 
     */
776
 
    UBool setSeparateDateTimePtn(const UnicodeString& dateSkeleton,
777
 
                                 const UnicodeString& timeSkeleton);
778
 
 
779
 
 
780
 
 
781
 
 
782
 
    /**
783
 
     * Generate interval pattern from existing resource
784
 
     *
785
 
     * It not only save the interval patterns,
786
 
     * but also return the extended skeleton and its best match skeleton.
787
 
     *
788
 
     * @param field           largest different calendar field
789
 
     * @param skeleton        skeleton
790
 
     * @param bestSkeleton    the best match skeleton which has interval pattern
791
 
     *                        defined in resource
792
 
     * @param differenceInfo  the difference between skeleton and best skeleton
793
 
     *         0 means the best matched skeleton is the same as input skeleton
794
 
     *         1 means the fields are the same, but field width are different
795
 
     *         2 means the only difference between fields are v/z,
796
 
     *        -1 means there are other fields difference
797
 
     *
798
 
     * @param extendedSkeleton      extended skeleton
799
 
     * @param extendedBestSkeleton  extended best match skeleton
800
 
     * @return                      whether the interval pattern is found
801
 
     *                              through extending skeleton or not.
802
 
     *                              TRUE if interval pattern is found by
803
 
     *                              extending skeleton, FALSE otherwise.
804
 
     * @internal ICU 4.0
805
 
     */
806
 
    UBool setIntervalPattern(UCalendarDateFields field,
807
 
                             const UnicodeString* skeleton,
808
 
                             const UnicodeString* bestSkeleton,
809
 
                             int8_t differenceInfo,
810
 
                             UnicodeString* extendedSkeleton = NULL,
811
 
                             UnicodeString* extendedBestSkeleton = NULL);
812
 
 
813
 
    /**
814
 
     * Adjust field width in best match interval pattern to match
815
 
     * the field width in input skeleton.
816
 
     *
817
 
     * TODO (xji) make a general solution
818
 
     * The adjusting rule can be:
819
 
     * 1. always adjust
820
 
     * 2. never adjust
821
 
     * 3. default adjust, which means adjust according to the following rules
822
 
     * 3.1 always adjust string, such as MMM and MMMM
823
 
     * 3.2 never adjust between string and numeric, such as MM and MMM
824
 
     * 3.3 always adjust year
825
 
     * 3.4 do not adjust 'd', 'h', or 'm' if h presents
826
 
     * 3.5 do not adjust 'M' if it is numeric(?)
827
 
     *
828
 
     * Since date interval format is well-formed format,
829
 
     * date and time skeletons are normalized previously,
830
 
     * till this stage, the adjust here is only "adjust strings, such as MMM
831
 
     * and MMMM, EEE and EEEE.
832
 
     *
833
 
     * @param inputSkeleton            the input skeleton
834
 
     * @param bestMatchSkeleton        the best match skeleton
835
 
     * @param bestMatchIntervalpattern the best match interval pattern
836
 
     * @param differenceInfo           the difference between 2 skeletons
837
 
     *                                 1 means only field width differs
838
 
     *                                 2 means v/z exchange
839
 
     * @param adjustedIntervalPattern  adjusted interval pattern
840
 
     * @internal ICU 4.0
841
 
     */
842
 
    static void U_EXPORT2 adjustFieldWidth(
843
 
                            const UnicodeString& inputSkeleton,
844
 
                            const UnicodeString& bestMatchSkeleton,
845
 
                            const UnicodeString& bestMatchIntervalPattern,
846
 
                            int8_t differenceInfo,
847
 
                            UnicodeString& adjustedIntervalPattern);
848
 
 
849
 
    /**
850
 
     * Concat a single date pattern with a time interval pattern,
851
 
     * set it into the intervalPatterns, while field is time field.
852
 
     * This is used to handle time interval patterns on skeleton with
853
 
     * both time and date. Present the date followed by
854
 
     * the range expression for the time.
855
 
     * @param format         date and time format
856
 
     * @param formatLen      format string length
857
 
     * @param datePattern    date pattern
858
 
     * @param field          time calendar field: AM_PM, HOUR, MINUTE
859
 
     * @param status         output param set to success/failure code on exit
860
 
     * @internal ICU 4.0
861
 
     */
862
 
    void concatSingleDate2TimeInterval(const UChar* format,
863
 
                                       int32_t formatLen,
864
 
                                       const UnicodeString& datePattern,
865
 
                                       UCalendarDateFields field,
866
 
                                       UErrorCode& status);
867
 
 
868
 
    /**
869
 
     * check whether a calendar field present in a skeleton.
870
 
     * @param field      calendar field need to check
871
 
     * @param skeleton   given skeleton on which to check the calendar field
872
 
     * @return           true if field present in a skeleton.
873
 
     * @internal ICU 4.0
874
 
     */
875
 
    static UBool U_EXPORT2 fieldExistsInSkeleton(UCalendarDateFields field,
876
 
                                                 const UnicodeString& skeleton);
877
 
 
878
 
 
879
 
    /**
880
 
     * Split interval patterns into 2 part.
881
 
     * @param intervalPattern  interval pattern
882
 
     * @return the index in interval pattern which split the pattern into 2 part
883
 
     * @internal ICU 4.0
884
 
     */
885
 
    static int32_t  U_EXPORT2 splitPatternInto2Part(const UnicodeString& intervalPattern);
886
 
 
887
 
 
888
 
    /**
889
 
     * Break interval patterns as 2 part and save them into pattern info.
890
 
     * @param field            calendar field
891
 
     * @param intervalPattern  interval pattern
892
 
     * @internal ICU 4.0
893
 
     */
894
 
    void setIntervalPattern(UCalendarDateFields field,
895
 
                            const UnicodeString& intervalPattern);
896
 
 
897
 
 
898
 
    /**
899
 
     * Break interval patterns as 2 part and save them into pattern info.
900
 
     * @param field            calendar field
901
 
     * @param intervalPattern  interval pattern
902
 
     * @param laterDateFirst   whether later date appear first in interval pattern
903
 
     * @internal ICU 4.0
904
 
     */
905
 
    void setIntervalPattern(UCalendarDateFields field,
906
 
                            const UnicodeString& intervalPattern,
907
 
                            UBool laterDateFirst);
908
 
 
909
 
 
910
 
    /**
911
 
     * Set pattern information.
912
 
     *
913
 
     * @param field            calendar field
914
 
     * @param firstPart        the first part in interval pattern
915
 
     * @param secondPart       the second part in interval pattern
916
 
     * @param laterDateFirst   whether the first date in intervalPattern
917
 
     *                         is earlier date or later date
918
 
     * @internal ICU 4.0
919
 
     */
920
 
    void setPatternInfo(UCalendarDateFields field,
921
 
                        const UnicodeString* firstPart,
922
 
                        const UnicodeString* secondpart,
923
 
                        UBool laterDateFirst);
924
 
 
925
 
 
926
 
    // from calendar field to pattern letter
927
 
    static const UChar fgCalendarFieldToPatternLetter[];
928
 
 
929
 
 
930
 
    /**
931
 
     * The interval patterns for this locale.
932
 
     */
933
 
    DateIntervalInfo*     fInfo;
934
 
 
935
 
    /**
936
 
     * The DateFormat object used to format single pattern
937
 
     */
938
 
    SimpleDateFormat*     fDateFormat;
939
 
 
940
 
    /**
941
 
     * The 2 calendars with the from and to date.
942
 
     * could re-use the calendar in fDateFormat,
943
 
     * but keeping 2 calendars make it clear and clean.
944
 
     */
945
 
    Calendar* fFromCalendar;
946
 
    Calendar* fToCalendar;
947
 
 
948
 
    /**
949
 
     * Date time pattern generator
950
 
     */
951
 
    DateTimePatternGenerator* fDtpng;
952
 
 
953
 
    /**
954
 
     * Following are interval information relavent (locale) to this formatter.
955
 
     */
956
 
    UnicodeString fSkeleton;
957
 
    PatternInfo fIntervalPatterns[DateIntervalInfo::kIPI_MAX_INDEX];
958
 
};
959
 
 
960
 
inline UBool
961
 
DateIntervalFormat::operator!=(const Format& other) const  {
962
 
    return !operator==(other);
963
 
}
964
 
 
965
 
U_NAMESPACE_END
966
 
 
967
 
#endif /* #if !UCONFIG_NO_FORMATTING */
968
 
 
969
 
#endif // _DTITVFMT_H__
970
 
//eof