1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 *******************************************************************************
5 * Copyright (C) 2011-2015, International Business Machines Corporation and
6 * others. All Rights Reserved.
7 *******************************************************************************
8 */
9
10 #include "unicode/utypes.h"
11
12 #if !UCONFIG_NO_FORMATTING
13
14 #include "unicode/calendar.h"
15 #include "unicode/tzfmt.h"
16 #include "unicode/numsys.h"
17 #include "unicode/uchar.h"
18 #include "unicode/udat.h"
19 #include "tzgnames.h"
20 #include "cmemory.h"
21 #include "cstring.h"
22 #include "putilimp.h"
23 #include "uassert.h"
24 #include "ucln_in.h"
25 #include "umutex.h"
26 #include "uresimp.h"
27 #include "ureslocs.h"
28 #include "uvector.h"
29 #include "zonemeta.h"
30 #include "tznames_impl.h" // TextTrieMap
31
32 U_NAMESPACE_BEGIN
33
34 // Bit flags used by the parse method.
35 // The order must match UTimeZoneFormatStyle enum.
36 #define ISO_Z_STYLE_FLAG 0x0080
37 #define ISO_LOCAL_STYLE_FLAG 0x0100
38 static const int16_t STYLE_PARSE_FLAGS[] = {
39 0x0001, // UTZFMT_STYLE_GENERIC_LOCATION,
40 0x0002, // UTZFMT_STYLE_GENERIC_LONG,
41 0x0004, // UTZFMT_STYLE_GENERIC_SHORT,
42 0x0008, // UTZFMT_STYLE_SPECIFIC_LONG,
43 0x0010, // UTZFMT_STYLE_SPECIFIC_SHORT,
44 0x0020, // UTZFMT_STYLE_LOCALIZED_GMT,
45 0x0040, // UTZFMT_STYLE_LOCALIZED_GMT_SHORT,
46 ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_SHORT,
47 ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT,
48 ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_FIXED,
49 ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED,
50 ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_FULL,
51 ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL,
52 ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_EXTENDED_FIXED,
53 ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED,
54 ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_EXTENDED_FULL,
55 ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL,
56 0x0200, // UTZFMT_STYLE_ZONE_ID,
57 0x0400, // UTZFMT_STYLE_ZONE_ID_SHORT,
58 0x0800 // UTZFMT_STYLE_EXEMPLAR_LOCATION
59 };
60
61 static const char gZoneStringsTag[] = "zoneStrings";
62 static const char gGmtFormatTag[]= "gmtFormat";
63 static const char gGmtZeroFormatTag[] = "gmtZeroFormat";
64 static const char gHourFormatTag[]= "hourFormat";
65
66 static const UChar TZID_GMT[] = {0x0045, 0x0074, 0x0063, 0x002F, 0x0047, 0x004D, 0x0054, 0}; // Etc/GMT
67 static const UChar UNKNOWN_ZONE_ID[] = {
68 0x0045, 0x0074, 0x0063, 0x002F, 0x0055, 0x006E, 0x006B, 0x006E, 0x006F, 0x0077, 0x006E, 0}; // Etc/Unknown
69 static const UChar UNKNOWN_SHORT_ZONE_ID[] = {0x0075, 0x006E, 0x006B, 0}; // unk
70 static const UChar UNKNOWN_LOCATION[] = {0x0055, 0x006E, 0x006B, 0x006E, 0x006F, 0x0077, 0x006E, 0}; // Unknown
71
72 static const UChar DEFAULT_GMT_PATTERN[] = {0x0047, 0x004D, 0x0054, 0x007B, 0x0030, 0x007D, 0}; // GMT{0}
73 //static const UChar DEFAULT_GMT_ZERO[] = {0x0047, 0x004D, 0x0054, 0}; // GMT
74 static const UChar DEFAULT_GMT_POSITIVE_HM[] = {0x002B, 0x0048, 0x003A, 0x006D, 0x006D, 0}; // +H:mm
75 static const UChar DEFAULT_GMT_POSITIVE_HMS[] = {0x002B, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0}; // +H:mm:ss
76 static const UChar DEFAULT_GMT_NEGATIVE_HM[] = {0x002D, 0x0048, 0x003A, 0x006D, 0x006D, 0}; // -H:mm
77 static const UChar DEFAULT_GMT_NEGATIVE_HMS[] = {0x002D, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0}; // -H:mm:ss
78 static const UChar DEFAULT_GMT_POSITIVE_H[] = {0x002B, 0x0048, 0}; // +H
79 static const UChar DEFAULT_GMT_NEGATIVE_H[] = {0x002D, 0x0048, 0}; // -H
80
81 static const UChar32 DEFAULT_GMT_DIGITS[] = {
82 0x0030, 0x0031, 0x0032, 0x0033, 0x0034,
83 0x0035, 0x0036, 0x0037, 0x0038, 0x0039
84 };
85
86 static const UChar DEFAULT_GMT_OFFSET_SEP = 0x003A; // ':'
87
88 static const UChar ARG0[] = {0x007B, 0x0030, 0x007D}; // "{0}"
89 static const int32_t ARG0_LEN = 3;
90
91 static const UChar DEFAULT_GMT_OFFSET_MINUTE_PATTERN[] = {0x006D, 0x006D, 0}; // "mm"
92 static const UChar DEFAULT_GMT_OFFSET_SECOND_PATTERN[] = {0x0073, 0x0073, 0}; // "ss"
93
94 static const UChar ALT_GMT_STRINGS[][4] = {
95 {0x0047, 0x004D, 0x0054, 0}, // GMT
96 {0x0055, 0x0054, 0x0043, 0}, // UTC
97 {0x0055, 0x0054, 0, 0}, // UT
98 {0, 0, 0, 0}
99 };
100
101 // Order of GMT offset pattern parsing, *_HMS must be evaluated first
102 // because *_HM is most likely a substring of *_HMS
103 static const int32_t PARSE_GMT_OFFSET_TYPES[] = {
104 UTZFMT_PAT_POSITIVE_HMS,
105 UTZFMT_PAT_NEGATIVE_HMS,
106 UTZFMT_PAT_POSITIVE_HM,
107 UTZFMT_PAT_NEGATIVE_HM,
108 UTZFMT_PAT_POSITIVE_H,
109 UTZFMT_PAT_NEGATIVE_H,
110 -1
111 };
112
113 static const UChar SINGLEQUOTE = 0x0027;
114 static const UChar PLUS = 0x002B;
115 static const UChar MINUS = 0x002D;
116 static const UChar ISO8601_UTC = 0x005A; // 'Z'
117 static const UChar ISO8601_SEP = 0x003A; // ':'
118
119 static const int32_t MILLIS_PER_HOUR = 60 * 60 * 1000;
120 static const int32_t MILLIS_PER_MINUTE = 60 * 1000;
121 static const int32_t MILLIS_PER_SECOND = 1000;
122
123 // Maximum offset (exclusive) in millisecond supported by offset formats
124 static int32_t MAX_OFFSET = 24 * MILLIS_PER_HOUR;
125
126 // Maximum values for GMT offset fields
127 static const int32_t MAX_OFFSET_HOUR = 23;
128 static const int32_t MAX_OFFSET_MINUTE = 59;
129 static const int32_t MAX_OFFSET_SECOND = 59;
130
131 static const int32_t UNKNOWN_OFFSET = 0x7FFFFFFF;
132
133 static const int32_t ALL_SIMPLE_NAME_TYPES = UTZNM_LONG_STANDARD | UTZNM_LONG_DAYLIGHT | UTZNM_SHORT_STANDARD | UTZNM_SHORT_DAYLIGHT | UTZNM_EXEMPLAR_LOCATION;
134 static const int32_t ALL_GENERIC_NAME_TYPES = UTZGNM_LOCATION | UTZGNM_LONG | UTZGNM_SHORT;
135
136 #define DIGIT_VAL(c) (0x0030 <= (c) && (c) <= 0x0039 ? (c) - 0x0030 : -1)
137 #define MAX_OFFSET_DIGITS 6
138
139 // Time Zone ID/Short ID trie
140 static TextTrieMap *gZoneIdTrie = NULL;
141 static icu::UInitOnce gZoneIdTrieInitOnce = U_INITONCE_INITIALIZER;
142
143 static TextTrieMap *gShortZoneIdTrie = NULL;
144 static icu::UInitOnce gShortZoneIdTrieInitOnce = U_INITONCE_INITIALIZER;
145
146 static UMutex gLock = U_MUTEX_INITIALIZER;
147
148 U_CDECL_BEGIN
149 /**
150 * Cleanup callback func
151 */
tzfmt_cleanup(void)152 static UBool U_CALLCONV tzfmt_cleanup(void)
153 {
154 if (gZoneIdTrie != NULL) {
155 delete gZoneIdTrie;
156 }
157 gZoneIdTrie = NULL;
158 gZoneIdTrieInitOnce.reset();
159
160 if (gShortZoneIdTrie != NULL) {
161 delete gShortZoneIdTrie;
162 }
163 gShortZoneIdTrie = NULL;
164 gShortZoneIdTrieInitOnce.reset();
165
166 return TRUE;
167 }
168 U_CDECL_END
169
170 // ------------------------------------------------------------------
171 // GMTOffsetField
172 //
173 // This class represents a localized GMT offset pattern
174 // item and used by TimeZoneFormat
175 // ------------------------------------------------------------------
176 class GMTOffsetField : public UMemory {
177 public:
178 enum FieldType {
179 TEXT = 0,
180 HOUR = 1,
181 MINUTE = 2,
182 SECOND = 4
183 };
184
185 virtual ~GMTOffsetField();
186
187 static GMTOffsetField* createText(const UnicodeString& text, UErrorCode& status);
188 static GMTOffsetField* createTimeField(FieldType type, uint8_t width, UErrorCode& status);
189 static UBool isValid(FieldType type, int32_t width);
190 static FieldType getTypeByLetter(UChar ch);
191
192 FieldType getType() const;
193 uint8_t getWidth() const;
194 const UChar* getPatternText(void) const;
195
196 private:
197 UChar* fText;
198 FieldType fType;
199 uint8_t fWidth;
200
201 GMTOffsetField();
202 };
203
GMTOffsetField()204 GMTOffsetField::GMTOffsetField()
205 : fText(NULL), fType(TEXT), fWidth(0) {
206 }
207
~GMTOffsetField()208 GMTOffsetField::~GMTOffsetField() {
209 if (fText) {
210 uprv_free(fText);
211 }
212 }
213
214 GMTOffsetField*
createText(const UnicodeString & text,UErrorCode & status)215 GMTOffsetField::createText(const UnicodeString& text, UErrorCode& status) {
216 if (U_FAILURE(status)) {
217 return NULL;
218 }
219 GMTOffsetField* result = new GMTOffsetField();
220 if (result == NULL) {
221 status = U_MEMORY_ALLOCATION_ERROR;
222 return NULL;
223 }
224
225 int32_t len = text.length();
226 result->fText = (UChar*)uprv_malloc((len + 1) * sizeof(UChar));
227 if (result->fText == NULL) {
228 status = U_MEMORY_ALLOCATION_ERROR;
229 delete result;
230 return NULL;
231 }
232 u_strncpy(result->fText, text.getBuffer(), len);
233 result->fText[len] = 0;
234 result->fType = TEXT;
235
236 return result;
237 }
238
239 GMTOffsetField*
createTimeField(FieldType type,uint8_t width,UErrorCode & status)240 GMTOffsetField::createTimeField(FieldType type, uint8_t width, UErrorCode& status) {
241 U_ASSERT(type != TEXT);
242 if (U_FAILURE(status)) {
243 return NULL;
244 }
245 GMTOffsetField* result = new GMTOffsetField();
246 if (result == NULL) {
247 status = U_MEMORY_ALLOCATION_ERROR;
248 return NULL;
249 }
250
251 result->fType = type;
252 result->fWidth = width;
253
254 return result;
255 }
256
257 UBool
isValid(FieldType type,int32_t width)258 GMTOffsetField::isValid(FieldType type, int32_t width) {
259 switch (type) {
260 case HOUR:
261 return (width == 1 || width == 2);
262 case MINUTE:
263 case SECOND:
264 return (width == 2);
265 default:
266 U_ASSERT(FALSE);
267 }
268 return (width > 0);
269 }
270
271 GMTOffsetField::FieldType
getTypeByLetter(UChar ch)272 GMTOffsetField::getTypeByLetter(UChar ch) {
273 if (ch == 0x0048 /* H */) {
274 return HOUR;
275 } else if (ch == 0x006D /* m */) {
276 return MINUTE;
277 } else if (ch == 0x0073 /* s */) {
278 return SECOND;
279 }
280 return TEXT;
281 }
282
283 inline GMTOffsetField::FieldType
getType() const284 GMTOffsetField::getType() const {
285 return fType;
286 }
287
288 inline uint8_t
getWidth() const289 GMTOffsetField::getWidth() const {
290 return fWidth;
291 }
292
293 inline const UChar*
getPatternText(void) const294 GMTOffsetField::getPatternText(void) const {
295 return fText;
296 }
297
298
299 U_CDECL_BEGIN
300 static void U_CALLCONV
deleteGMTOffsetField(void * obj)301 deleteGMTOffsetField(void *obj) {
302 delete static_cast<GMTOffsetField *>(obj);
303 }
304 U_CDECL_END
305
306
307 // ------------------------------------------------------------------
308 // TimeZoneFormat
309 // ------------------------------------------------------------------
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TimeZoneFormat)310 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TimeZoneFormat)
311
312 TimeZoneFormat::TimeZoneFormat(const Locale& locale, UErrorCode& status)
313 : fLocale(locale), fTimeZoneNames(NULL), fTimeZoneGenericNames(NULL),
314 fDefParseOptionFlags(0), fTZDBTimeZoneNames(NULL) {
315
316 for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
317 fGMTOffsetPatternItems[i] = NULL;
318 }
319
320 const char* region = fLocale.getCountry();
321 int32_t regionLen = uprv_strlen(region);
322 if (regionLen == 0) {
323 char loc[ULOC_FULLNAME_CAPACITY];
324 uloc_addLikelySubtags(fLocale.getName(), loc, sizeof(loc), &status);
325
326 regionLen = uloc_getCountry(loc, fTargetRegion, sizeof(fTargetRegion), &status);
327 if (U_SUCCESS(status)) {
328 fTargetRegion[regionLen] = 0;
329 } else {
330 return;
331 }
332 } else if (regionLen < (int32_t)sizeof(fTargetRegion)) {
333 uprv_strcpy(fTargetRegion, region);
334 } else {
335 fTargetRegion[0] = 0;
336 }
337
338 fTimeZoneNames = TimeZoneNames::createInstance(locale, status);
339 // fTimeZoneGenericNames is lazily instantiated
340 if (U_FAILURE(status)) {
341 return;
342 }
343
344 const UChar* gmtPattern = NULL;
345 const UChar* hourFormats = NULL;
346
347 UResourceBundle *zoneBundle = ures_open(U_ICUDATA_ZONE, locale.getName(), &status);
348 UResourceBundle *zoneStringsArray = ures_getByKeyWithFallback(zoneBundle, gZoneStringsTag, NULL, &status);
349 if (U_SUCCESS(status)) {
350 const UChar* resStr;
351 int32_t len;
352 resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gGmtFormatTag, &len, &status);
353 if (len > 0) {
354 gmtPattern = resStr;
355 }
356 resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gGmtZeroFormatTag, &len, &status);
357 if (len > 0) {
358 fGMTZeroFormat.setTo(TRUE, resStr, len);
359 }
360 resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gHourFormatTag, &len, &status);
361 if (len > 0) {
362 hourFormats = resStr;
363 }
364 ures_close(zoneStringsArray);
365 ures_close(zoneBundle);
366 }
367
368 if (gmtPattern == NULL) {
369 gmtPattern = DEFAULT_GMT_PATTERN;
370 }
371 initGMTPattern(UnicodeString(TRUE, gmtPattern, -1), status);
372
373 UBool useDefaultOffsetPatterns = TRUE;
374 if (hourFormats) {
375 UChar *sep = u_strchr(hourFormats, (UChar)0x003B /* ';' */);
376 if (sep != NULL) {
377 UErrorCode tmpStatus = U_ZERO_ERROR;
378 fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM].setTo(FALSE, hourFormats, (int32_t)(sep - hourFormats));
379 fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM].setTo(TRUE, sep + 1, -1);
380 expandOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HMS], tmpStatus);
381 expandOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HMS], tmpStatus);
382 truncateOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_H], tmpStatus);
383 truncateOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_H], tmpStatus);
384 if (U_SUCCESS(tmpStatus)) {
385 useDefaultOffsetPatterns = FALSE;
386 }
387 }
388 }
389 if (useDefaultOffsetPatterns) {
390 fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_H].setTo(TRUE, DEFAULT_GMT_POSITIVE_H, -1);
391 fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM].setTo(TRUE, DEFAULT_GMT_POSITIVE_HM, -1);
392 fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HMS].setTo(TRUE, DEFAULT_GMT_POSITIVE_HMS, -1);
393 fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_H].setTo(TRUE, DEFAULT_GMT_NEGATIVE_H, -1);
394 fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM].setTo(TRUE, DEFAULT_GMT_NEGATIVE_HM, -1);
395 fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HMS].setTo(TRUE, DEFAULT_GMT_NEGATIVE_HMS, -1);
396 }
397 initGMTOffsetPatterns(status);
398
399 NumberingSystem* ns = NumberingSystem::createInstance(locale, status);
400 UBool useDefDigits = TRUE;
401 if (ns && !ns->isAlgorithmic()) {
402 UnicodeString digits = ns->getDescription();
403 useDefDigits = !toCodePoints(digits, fGMTOffsetDigits, 10);
404 }
405 if (useDefDigits) {
406 uprv_memcpy(fGMTOffsetDigits, DEFAULT_GMT_DIGITS, sizeof(UChar32) * 10);
407 }
408 delete ns;
409 }
410
TimeZoneFormat(const TimeZoneFormat & other)411 TimeZoneFormat::TimeZoneFormat(const TimeZoneFormat& other)
412 : Format(other), fTimeZoneNames(NULL), fTimeZoneGenericNames(NULL),
413 fTZDBTimeZoneNames(NULL) {
414
415 for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
416 fGMTOffsetPatternItems[i] = NULL;
417 }
418 *this = other;
419 }
420
421
~TimeZoneFormat()422 TimeZoneFormat::~TimeZoneFormat() {
423 delete fTimeZoneNames;
424 delete fTimeZoneGenericNames;
425 delete fTZDBTimeZoneNames;
426 for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
427 delete fGMTOffsetPatternItems[i];
428 }
429 }
430
431 TimeZoneFormat&
operator =(const TimeZoneFormat & other)432 TimeZoneFormat::operator=(const TimeZoneFormat& other) {
433 if (this == &other) {
434 return *this;
435 }
436
437 delete fTimeZoneNames;
438 delete fTimeZoneGenericNames;
439 fTimeZoneGenericNames = NULL;
440 delete fTZDBTimeZoneNames;
441 fTZDBTimeZoneNames = NULL;
442
443 fLocale = other.fLocale;
444 uprv_memcpy(fTargetRegion, other.fTargetRegion, sizeof(fTargetRegion));
445
446 fTimeZoneNames = other.fTimeZoneNames->clone();
447 if (other.fTimeZoneGenericNames) {
448 // TODO: this test has dubious thread safety.
449 fTimeZoneGenericNames = other.fTimeZoneGenericNames->clone();
450 }
451
452 fGMTPattern = other.fGMTPattern;
453 fGMTPatternPrefix = other.fGMTPatternPrefix;
454 fGMTPatternSuffix = other.fGMTPatternSuffix;
455
456 UErrorCode status = U_ZERO_ERROR;
457 for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
458 fGMTOffsetPatterns[i] = other.fGMTOffsetPatterns[i];
459 delete fGMTOffsetPatternItems[i];
460 fGMTOffsetPatternItems[i] = NULL;
461 }
462 initGMTOffsetPatterns(status);
463 U_ASSERT(U_SUCCESS(status));
464
465 fGMTZeroFormat = other.fGMTZeroFormat;
466
467 uprv_memcpy(fGMTOffsetDigits, other.fGMTOffsetDigits, sizeof(fGMTOffsetDigits));
468
469 fDefParseOptionFlags = other.fDefParseOptionFlags;
470
471 return *this;
472 }
473
474
475 UBool
operator ==(const Format & other) const476 TimeZoneFormat::operator==(const Format& other) const {
477 TimeZoneFormat* tzfmt = (TimeZoneFormat*)&other;
478
479 UBool isEqual =
480 fLocale == tzfmt->fLocale
481 && fGMTPattern == tzfmt->fGMTPattern
482 && fGMTZeroFormat == tzfmt->fGMTZeroFormat
483 && *fTimeZoneNames == *tzfmt->fTimeZoneNames;
484
485 for (int32_t i = 0; i < UTZFMT_PAT_COUNT && isEqual; i++) {
486 isEqual = fGMTOffsetPatterns[i] == tzfmt->fGMTOffsetPatterns[i];
487 }
488 for (int32_t i = 0; i < 10 && isEqual; i++) {
489 isEqual = fGMTOffsetDigits[i] == tzfmt->fGMTOffsetDigits[i];
490 }
491 // TODO
492 // Check fTimeZoneGenericNames. For now,
493 // if fTimeZoneNames is same, fTimeZoneGenericNames should
494 // be also equivalent.
495 return isEqual;
496 }
497
498 Format*
clone() const499 TimeZoneFormat::clone() const {
500 return new TimeZoneFormat(*this);
501 }
502
503 TimeZoneFormat* U_EXPORT2
createInstance(const Locale & locale,UErrorCode & status)504 TimeZoneFormat::createInstance(const Locale& locale, UErrorCode& status) {
505 TimeZoneFormat* tzfmt = new TimeZoneFormat(locale, status);
506 if (U_SUCCESS(status)) {
507 return tzfmt;
508 }
509 delete tzfmt;
510 return NULL;
511 }
512
513 // ------------------------------------------------------------------
514 // Setter and Getter
515
516 const TimeZoneNames*
getTimeZoneNames() const517 TimeZoneFormat::getTimeZoneNames() const {
518 return (const TimeZoneNames*)fTimeZoneNames;
519 }
520
521 void
adoptTimeZoneNames(TimeZoneNames * tznames)522 TimeZoneFormat::adoptTimeZoneNames(TimeZoneNames *tznames) {
523 delete fTimeZoneNames;
524 fTimeZoneNames = tznames;
525
526 // TODO - We should also update fTimeZoneGenericNames
527 }
528
529 void
setTimeZoneNames(const TimeZoneNames & tznames)530 TimeZoneFormat::setTimeZoneNames(const TimeZoneNames &tznames) {
531 delete fTimeZoneNames;
532 fTimeZoneNames = tznames.clone();
533
534 // TODO - We should also update fTimeZoneGenericNames
535 }
536
537 void
setDefaultParseOptions(uint32_t flags)538 TimeZoneFormat::setDefaultParseOptions(uint32_t flags) {
539 fDefParseOptionFlags = flags;
540 }
541
542 uint32_t
getDefaultParseOptions(void) const543 TimeZoneFormat::getDefaultParseOptions(void) const {
544 return fDefParseOptionFlags;
545 }
546
547
548 UnicodeString&
getGMTPattern(UnicodeString & pattern) const549 TimeZoneFormat::getGMTPattern(UnicodeString& pattern) const {
550 return pattern.setTo(fGMTPattern);
551 }
552
553 void
setGMTPattern(const UnicodeString & pattern,UErrorCode & status)554 TimeZoneFormat::setGMTPattern(const UnicodeString& pattern, UErrorCode& status) {
555 initGMTPattern(pattern, status);
556 }
557
558 UnicodeString&
getGMTOffsetPattern(UTimeZoneFormatGMTOffsetPatternType type,UnicodeString & pattern) const559 TimeZoneFormat::getGMTOffsetPattern(UTimeZoneFormatGMTOffsetPatternType type, UnicodeString& pattern) const {
560 return pattern.setTo(fGMTOffsetPatterns[type]);
561 }
562
563 void
setGMTOffsetPattern(UTimeZoneFormatGMTOffsetPatternType type,const UnicodeString & pattern,UErrorCode & status)564 TimeZoneFormat::setGMTOffsetPattern(UTimeZoneFormatGMTOffsetPatternType type, const UnicodeString& pattern, UErrorCode& status) {
565 if (U_FAILURE(status)) {
566 return;
567 }
568 if (pattern == fGMTOffsetPatterns[type]) {
569 // No need to reset
570 return;
571 }
572
573 OffsetFields required = FIELDS_HM;
574 switch (type) {
575 case UTZFMT_PAT_POSITIVE_H:
576 case UTZFMT_PAT_NEGATIVE_H:
577 required = FIELDS_H;
578 break;
579 case UTZFMT_PAT_POSITIVE_HM:
580 case UTZFMT_PAT_NEGATIVE_HM:
581 required = FIELDS_HM;
582 break;
583 case UTZFMT_PAT_POSITIVE_HMS:
584 case UTZFMT_PAT_NEGATIVE_HMS:
585 required = FIELDS_HMS;
586 break;
587 default:
588 U_ASSERT(FALSE);
589 break;
590 }
591
592 UVector* patternItems = parseOffsetPattern(pattern, required, status);
593 if (patternItems == NULL) {
594 return;
595 }
596
597 fGMTOffsetPatterns[type].setTo(pattern);
598 delete fGMTOffsetPatternItems[type];
599 fGMTOffsetPatternItems[type] = patternItems;
600 checkAbuttingHoursAndMinutes();
601 }
602
603 UnicodeString&
getGMTOffsetDigits(UnicodeString & digits) const604 TimeZoneFormat::getGMTOffsetDigits(UnicodeString& digits) const {
605 digits.remove();
606 for (int32_t i = 0; i < 10; i++) {
607 digits.append(fGMTOffsetDigits[i]);
608 }
609 return digits;
610 }
611
612 void
setGMTOffsetDigits(const UnicodeString & digits,UErrorCode & status)613 TimeZoneFormat::setGMTOffsetDigits(const UnicodeString& digits, UErrorCode& status) {
614 if (U_FAILURE(status)) {
615 return;
616 }
617 UChar32 digitArray[10];
618 if (!toCodePoints(digits, digitArray, 10)) {
619 status = U_ILLEGAL_ARGUMENT_ERROR;
620 return;
621 }
622 uprv_memcpy(fGMTOffsetDigits, digitArray, sizeof(UChar32)*10);
623 }
624
625 UnicodeString&
getGMTZeroFormat(UnicodeString & gmtZeroFormat) const626 TimeZoneFormat::getGMTZeroFormat(UnicodeString& gmtZeroFormat) const {
627 return gmtZeroFormat.setTo(fGMTZeroFormat);
628 }
629
630 void
setGMTZeroFormat(const UnicodeString & gmtZeroFormat,UErrorCode & status)631 TimeZoneFormat::setGMTZeroFormat(const UnicodeString& gmtZeroFormat, UErrorCode& status) {
632 if (U_SUCCESS(status)) {
633 if (gmtZeroFormat.isEmpty()) {
634 status = U_ILLEGAL_ARGUMENT_ERROR;
635 } else if (gmtZeroFormat != fGMTZeroFormat) {
636 fGMTZeroFormat.setTo(gmtZeroFormat);
637 }
638 }
639 }
640
641 // ------------------------------------------------------------------
642 // Format and Parse
643
644 UnicodeString&
format(UTimeZoneFormatStyle style,const TimeZone & tz,UDate date,UnicodeString & name,UTimeZoneFormatTimeType * timeType) const645 TimeZoneFormat::format(UTimeZoneFormatStyle style, const TimeZone& tz, UDate date,
646 UnicodeString& name, UTimeZoneFormatTimeType* timeType /* = NULL */) const {
647 if (timeType) {
648 *timeType = UTZFMT_TIME_TYPE_UNKNOWN;
649 }
650
651 UBool noOffsetFormatFallback = FALSE;
652
653 switch (style) {
654 case UTZFMT_STYLE_GENERIC_LOCATION:
655 formatGeneric(tz, UTZGNM_LOCATION, date, name);
656 break;
657 case UTZFMT_STYLE_GENERIC_LONG:
658 formatGeneric(tz, UTZGNM_LONG, date, name);
659 break;
660 case UTZFMT_STYLE_GENERIC_SHORT:
661 formatGeneric(tz, UTZGNM_SHORT, date, name);
662 break;
663 case UTZFMT_STYLE_SPECIFIC_LONG:
664 formatSpecific(tz, UTZNM_LONG_STANDARD, UTZNM_LONG_DAYLIGHT, date, name, timeType);
665 break;
666 case UTZFMT_STYLE_SPECIFIC_SHORT:
667 formatSpecific(tz, UTZNM_SHORT_STANDARD, UTZNM_SHORT_DAYLIGHT, date, name, timeType);
668 break;
669
670 case UTZFMT_STYLE_ZONE_ID:
671 tz.getID(name);
672 noOffsetFormatFallback = TRUE;
673 break;
674 case UTZFMT_STYLE_ZONE_ID_SHORT:
675 {
676 const UChar* shortID = ZoneMeta::getShortID(tz);
677 if (shortID == NULL) {
678 shortID = UNKNOWN_SHORT_ZONE_ID;
679 }
680 name.setTo(shortID, -1);
681 }
682 noOffsetFormatFallback = TRUE;
683 break;
684
685 case UTZFMT_STYLE_EXEMPLAR_LOCATION:
686 formatExemplarLocation(tz, name);
687 noOffsetFormatFallback = TRUE;
688 break;
689
690 default:
691 // will be handled below
692 break;
693 }
694
695 if (name.isEmpty() && !noOffsetFormatFallback) {
696 UErrorCode status = U_ZERO_ERROR;
697 int32_t rawOffset, dstOffset;
698 tz.getOffset(date, FALSE, rawOffset, dstOffset, status);
699 int32_t offset = rawOffset + dstOffset;
700 if (U_SUCCESS(status)) {
701 switch (style) {
702 case UTZFMT_STYLE_GENERIC_LOCATION:
703 case UTZFMT_STYLE_GENERIC_LONG:
704 case UTZFMT_STYLE_SPECIFIC_LONG:
705 case UTZFMT_STYLE_LOCALIZED_GMT:
706 formatOffsetLocalizedGMT(offset, name, status);
707 break;
708
709 case UTZFMT_STYLE_GENERIC_SHORT:
710 case UTZFMT_STYLE_SPECIFIC_SHORT:
711 case UTZFMT_STYLE_LOCALIZED_GMT_SHORT:
712 formatOffsetShortLocalizedGMT(offset, name, status);
713 break;
714
715 case UTZFMT_STYLE_ISO_BASIC_SHORT:
716 formatOffsetISO8601Basic(offset, TRUE, TRUE, TRUE, name, status);
717 break;
718
719 case UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT:
720 formatOffsetISO8601Basic(offset, FALSE, TRUE, TRUE, name, status);
721 break;
722
723 case UTZFMT_STYLE_ISO_BASIC_FIXED:
724 formatOffsetISO8601Basic(offset, TRUE, FALSE, TRUE, name, status);
725 break;
726
727 case UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED:
728 formatOffsetISO8601Basic(offset, FALSE, FALSE, TRUE, name, status);
729 break;
730
731 case UTZFMT_STYLE_ISO_EXTENDED_FIXED:
732 formatOffsetISO8601Extended(offset, TRUE, FALSE, TRUE, name, status);
733 break;
734
735 case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED:
736 formatOffsetISO8601Extended(offset, FALSE, FALSE, TRUE, name, status);
737 break;
738
739 case UTZFMT_STYLE_ISO_BASIC_FULL:
740 formatOffsetISO8601Basic(offset, TRUE, FALSE, FALSE, name, status);
741 break;
742
743 case UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL:
744 formatOffsetISO8601Basic(offset, FALSE, FALSE, FALSE, name, status);
745 break;
746
747 case UTZFMT_STYLE_ISO_EXTENDED_FULL:
748 formatOffsetISO8601Extended(offset, TRUE, FALSE, FALSE, name, status);
749 break;
750
751 case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL:
752 formatOffsetISO8601Extended(offset, FALSE, FALSE, FALSE, name, status);
753 break;
754
755 default:
756 // UTZFMT_STYLE_ZONE_ID, UTZFMT_STYLE_ZONE_ID_SHORT, UTZFMT_STYLE_EXEMPLAR_LOCATION
757 break;
758 }
759
760 if (timeType) {
761 *timeType = (dstOffset != 0) ? UTZFMT_TIME_TYPE_DAYLIGHT : UTZFMT_TIME_TYPE_STANDARD;
762 }
763 }
764 }
765
766 return name;
767 }
768
769 UnicodeString&
format(const Formattable & obj,UnicodeString & appendTo,FieldPosition & pos,UErrorCode & status) const770 TimeZoneFormat::format(const Formattable& obj, UnicodeString& appendTo,
771 FieldPosition& pos, UErrorCode& status) const {
772 if (U_FAILURE(status)) {
773 return appendTo;
774 }
775 UDate date = Calendar::getNow();
776 if (obj.getType() == Formattable::kObject) {
777 const UObject* formatObj = obj.getObject();
778 const TimeZone* tz = dynamic_cast<const TimeZone*>(formatObj);
779 if (tz == NULL) {
780 const Calendar* cal = dynamic_cast<const Calendar*>(formatObj);
781 if (cal != NULL) {
782 tz = &cal->getTimeZone();
783 date = cal->getTime(status);
784 }
785 }
786 if (tz != NULL) {
787 int32_t rawOffset, dstOffset;
788 tz->getOffset(date, FALSE, rawOffset, dstOffset, status);
789 UChar buf[32];
790 UnicodeString result(buf, 0, UPRV_LENGTHOF(buf));
791 formatOffsetLocalizedGMT(rawOffset + dstOffset, result, status);
792 if (U_SUCCESS(status)) {
793 appendTo.append(result);
794 if (pos.getField() == UDAT_TIMEZONE_FIELD) {
795 pos.setBeginIndex(0);
796 pos.setEndIndex(result.length());
797 }
798 }
799 }
800 }
801 return appendTo;
802 }
803
804 TimeZone*
parse(UTimeZoneFormatStyle style,const UnicodeString & text,ParsePosition & pos,UTimeZoneFormatTimeType * timeType) const805 TimeZoneFormat::parse(UTimeZoneFormatStyle style, const UnicodeString& text, ParsePosition& pos,
806 UTimeZoneFormatTimeType* timeType /*= NULL*/) const {
807 return parse(style, text, pos, getDefaultParseOptions(), timeType);
808 }
809
810 TimeZone*
parse(UTimeZoneFormatStyle style,const UnicodeString & text,ParsePosition & pos,int32_t parseOptions,UTimeZoneFormatTimeType * timeType) const811 TimeZoneFormat::parse(UTimeZoneFormatStyle style, const UnicodeString& text, ParsePosition& pos,
812 int32_t parseOptions, UTimeZoneFormatTimeType* timeType /* = NULL */) const {
813 if (timeType) {
814 *timeType = UTZFMT_TIME_TYPE_UNKNOWN;
815 }
816
817 int32_t startIdx = pos.getIndex();
818 int32_t maxPos = text.length();
819 int32_t offset;
820
821 // Styles using localized GMT format as fallback
822 UBool fallbackLocalizedGMT =
823 (style == UTZFMT_STYLE_SPECIFIC_LONG || style == UTZFMT_STYLE_GENERIC_LONG || style == UTZFMT_STYLE_GENERIC_LOCATION);
824 UBool fallbackShortLocalizedGMT =
825 (style == UTZFMT_STYLE_SPECIFIC_SHORT || style == UTZFMT_STYLE_GENERIC_SHORT);
826
827 int32_t evaluated = 0; // bit flags representing already evaluated styles
828 ParsePosition tmpPos(startIdx);
829
830 int32_t parsedOffset = UNKNOWN_OFFSET; // stores successfully parsed offset for later use
831 int32_t parsedPos = -1; // stores successfully parsed offset position for later use
832
833 // Try localized GMT format first if necessary
834 if (fallbackLocalizedGMT || fallbackShortLocalizedGMT) {
835 UBool hasDigitOffset = FALSE;
836 offset = parseOffsetLocalizedGMT(text, tmpPos, fallbackShortLocalizedGMT, &hasDigitOffset);
837 if (tmpPos.getErrorIndex() == -1) {
838 // Even when the input text was successfully parsed as a localized GMT format text,
839 // we may still need to evaluate the specified style if -
840 // 1) GMT zero format was used, and
841 // 2) The input text was not completely processed
842 if (tmpPos.getIndex() == maxPos || hasDigitOffset) {
843 pos.setIndex(tmpPos.getIndex());
844 return createTimeZoneForOffset(offset);
845 }
846 parsedOffset = offset;
847 parsedPos = tmpPos.getIndex();
848 }
849 // Note: For now, no distinction between long/short localized GMT format in the parser.
850 // This might be changed in future.
851 // evaluated |= (fallbackLocalizedGMT ? STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT] : STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT]);
852 evaluated |= STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT] | STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT];
853 }
854
855 UErrorCode status = U_ZERO_ERROR;
856 UChar tzIDBuf[32];
857 UnicodeString tzID(tzIDBuf, 0, UPRV_LENGTHOF(tzIDBuf));
858
859 UBool parseTZDBAbbrev = ((parseOptions & UTZFMT_PARSE_OPTION_TZ_DATABASE_ABBREVIATIONS) != 0);
860
861 // Try the specified style
862 switch (style) {
863 case UTZFMT_STYLE_LOCALIZED_GMT:
864 {
865 tmpPos.setIndex(startIdx);
866 tmpPos.setErrorIndex(-1);
867
868 offset = parseOffsetLocalizedGMT(text, tmpPos);
869 if (tmpPos.getErrorIndex() == -1) {
870 pos.setIndex(tmpPos.getIndex());
871 return createTimeZoneForOffset(offset);
872 }
873
874 // Note: For now, no distinction between long/short localized GMT format in the parser.
875 // This might be changed in future.
876 evaluated |= STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT];
877
878 break;
879 }
880 case UTZFMT_STYLE_LOCALIZED_GMT_SHORT:
881 {
882 tmpPos.setIndex(startIdx);
883 tmpPos.setErrorIndex(-1);
884
885 offset = parseOffsetShortLocalizedGMT(text, tmpPos);
886 if (tmpPos.getErrorIndex() == -1) {
887 pos.setIndex(tmpPos.getIndex());
888 return createTimeZoneForOffset(offset);
889 }
890
891 // Note: For now, no distinction between long/short localized GMT format in the parser.
892 // This might be changed in future.
893 evaluated |= STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT];
894
895 break;
896 }
897 case UTZFMT_STYLE_ISO_BASIC_SHORT:
898 case UTZFMT_STYLE_ISO_BASIC_FIXED:
899 case UTZFMT_STYLE_ISO_BASIC_FULL:
900 case UTZFMT_STYLE_ISO_EXTENDED_FIXED:
901 case UTZFMT_STYLE_ISO_EXTENDED_FULL:
902 {
903 tmpPos.setIndex(startIdx);
904 tmpPos.setErrorIndex(-1);
905
906 offset = parseOffsetISO8601(text, tmpPos);
907 if (tmpPos.getErrorIndex() == -1) {
908 pos.setIndex(tmpPos.getIndex());
909 return createTimeZoneForOffset(offset);
910 }
911
912 break;
913 }
914
915 case UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT:
916 case UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED:
917 case UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL:
918 case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED:
919 case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL:
920 {
921 tmpPos.setIndex(startIdx);
922 tmpPos.setErrorIndex(-1);
923
924 // Exclude the case of UTC Indicator "Z" here
925 UBool hasDigitOffset = FALSE;
926 offset = parseOffsetISO8601(text, tmpPos, FALSE, &hasDigitOffset);
927 if (tmpPos.getErrorIndex() == -1 && hasDigitOffset) {
928 pos.setIndex(tmpPos.getIndex());
929 return createTimeZoneForOffset(offset);
930 }
931
932 break;
933 }
934
935 case UTZFMT_STYLE_SPECIFIC_LONG:
936 case UTZFMT_STYLE_SPECIFIC_SHORT:
937 {
938 // Specific styles
939 int32_t nameTypes = 0;
940 if (style == UTZFMT_STYLE_SPECIFIC_LONG) {
941 nameTypes = (UTZNM_LONG_STANDARD | UTZNM_LONG_DAYLIGHT);
942 } else {
943 U_ASSERT(style == UTZFMT_STYLE_SPECIFIC_SHORT);
944 nameTypes = (UTZNM_SHORT_STANDARD | UTZNM_SHORT_DAYLIGHT);
945 }
946 LocalPointer<TimeZoneNames::MatchInfoCollection> specificMatches(fTimeZoneNames->find(text, startIdx, nameTypes, status));
947 if (U_FAILURE(status)) {
948 pos.setErrorIndex(startIdx);
949 return NULL;
950 }
951 if (!specificMatches.isNull()) {
952 int32_t matchIdx = -1;
953 int32_t matchPos = -1;
954 for (int32_t i = 0; i < specificMatches->size(); i++) {
955 matchPos = startIdx + specificMatches->getMatchLengthAt(i);
956 if (matchPos > parsedPos) {
957 matchIdx = i;
958 parsedPos = matchPos;
959 }
960 }
961 if (matchIdx >= 0) {
962 if (timeType) {
963 *timeType = getTimeType(specificMatches->getNameTypeAt(matchIdx));
964 }
965 pos.setIndex(matchPos);
966 getTimeZoneID(specificMatches.getAlias(), matchIdx, tzID);
967 U_ASSERT(!tzID.isEmpty());
968 return TimeZone::createTimeZone(tzID);
969 }
970 }
971
972 if (parseTZDBAbbrev && style == UTZFMT_STYLE_SPECIFIC_SHORT) {
973 U_ASSERT((nameTypes & UTZNM_SHORT_STANDARD) != 0);
974 U_ASSERT((nameTypes & UTZNM_SHORT_DAYLIGHT) != 0);
975
976 const TZDBTimeZoneNames *tzdbTimeZoneNames = getTZDBTimeZoneNames(status);
977 if (U_SUCCESS(status)) {
978 LocalPointer<TimeZoneNames::MatchInfoCollection> tzdbNameMatches(
979 tzdbTimeZoneNames->find(text, startIdx, nameTypes, status));
980 if (U_FAILURE(status)) {
981 pos.setErrorIndex(startIdx);
982 return NULL;
983 }
984 if (!tzdbNameMatches.isNull()) {
985 int32_t matchIdx = -1;
986 int32_t matchPos = -1;
987 for (int32_t i = 0; i < tzdbNameMatches->size(); i++) {
988 matchPos = startIdx + tzdbNameMatches->getMatchLengthAt(i);
989 if (matchPos > parsedPos) {
990 matchIdx = i;
991 parsedPos = matchPos;
992 }
993 }
994 if (matchIdx >= 0) {
995 if (timeType) {
996 *timeType = getTimeType(tzdbNameMatches->getNameTypeAt(matchIdx));
997 }
998 pos.setIndex(matchPos);
999 getTimeZoneID(tzdbNameMatches.getAlias(), matchIdx, tzID);
1000 U_ASSERT(!tzID.isEmpty());
1001 return TimeZone::createTimeZone(tzID);
1002 }
1003 }
1004 }
1005 }
1006 break;
1007 }
1008 case UTZFMT_STYLE_GENERIC_LONG:
1009 case UTZFMT_STYLE_GENERIC_SHORT:
1010 case UTZFMT_STYLE_GENERIC_LOCATION:
1011 {
1012 int32_t genericNameTypes = 0;
1013 switch (style) {
1014 case UTZFMT_STYLE_GENERIC_LOCATION:
1015 genericNameTypes = UTZGNM_LOCATION;
1016 break;
1017
1018 case UTZFMT_STYLE_GENERIC_LONG:
1019 genericNameTypes = UTZGNM_LONG | UTZGNM_LOCATION;
1020 break;
1021
1022 case UTZFMT_STYLE_GENERIC_SHORT:
1023 genericNameTypes = UTZGNM_SHORT | UTZGNM_LOCATION;
1024 break;
1025
1026 default:
1027 U_ASSERT(FALSE);
1028 }
1029
1030 int32_t len = 0;
1031 UTimeZoneFormatTimeType tt = UTZFMT_TIME_TYPE_UNKNOWN;
1032 const TimeZoneGenericNames *gnames = getTimeZoneGenericNames(status);
1033 if (U_SUCCESS(status)) {
1034 len = gnames->findBestMatch(text, startIdx, genericNameTypes, tzID, tt, status);
1035 }
1036 if (U_FAILURE(status)) {
1037 pos.setErrorIndex(startIdx);
1038 return NULL;
1039 }
1040 if (len > 0) {
1041 // Found a match
1042 if (timeType) {
1043 *timeType = tt;
1044 }
1045 pos.setIndex(startIdx + len);
1046 U_ASSERT(!tzID.isEmpty());
1047 return TimeZone::createTimeZone(tzID);
1048 }
1049
1050 break;
1051 }
1052 case UTZFMT_STYLE_ZONE_ID:
1053 {
1054 tmpPos.setIndex(startIdx);
1055 tmpPos.setErrorIndex(-1);
1056
1057 parseZoneID(text, tmpPos, tzID);
1058 if (tmpPos.getErrorIndex() == -1) {
1059 pos.setIndex(tmpPos.getIndex());
1060 return TimeZone::createTimeZone(tzID);
1061 }
1062 break;
1063 }
1064 case UTZFMT_STYLE_ZONE_ID_SHORT:
1065 {
1066 tmpPos.setIndex(startIdx);
1067 tmpPos.setErrorIndex(-1);
1068
1069 parseShortZoneID(text, tmpPos, tzID);
1070 if (tmpPos.getErrorIndex() == -1) {
1071 pos.setIndex(tmpPos.getIndex());
1072 return TimeZone::createTimeZone(tzID);
1073 }
1074 break;
1075 }
1076 case UTZFMT_STYLE_EXEMPLAR_LOCATION:
1077 {
1078 tmpPos.setIndex(startIdx);
1079 tmpPos.setErrorIndex(-1);
1080
1081 parseExemplarLocation(text, tmpPos, tzID);
1082 if (tmpPos.getErrorIndex() == -1) {
1083 pos.setIndex(tmpPos.getIndex());
1084 return TimeZone::createTimeZone(tzID);
1085 }
1086 break;
1087 }
1088 }
1089 evaluated |= STYLE_PARSE_FLAGS[style];
1090
1091
1092 if (parsedPos > startIdx) {
1093 // When the specified style is one of SPECIFIC_XXX or GENERIC_XXX, we tried to parse the input
1094 // as localized GMT format earlier. If parsedOffset is positive, it means it was successfully
1095 // parsed as localized GMT format, but offset digits were not detected (more specifically, GMT
1096 // zero format). Then, it tried to find a match within the set of display names, but could not
1097 // find a match. At this point, we can safely assume the input text contains the localized
1098 // GMT format.
1099 U_ASSERT(parsedOffset != UNKNOWN_OFFSET);
1100 pos.setIndex(parsedPos);
1101 return createTimeZoneForOffset(parsedOffset);
1102 }
1103
1104 // Failed to parse the input text as the time zone format in the specified style.
1105 // Check the longest match among other styles below.
1106 UChar parsedIDBuf[32];
1107 UnicodeString parsedID(parsedIDBuf, 0, UPRV_LENGTHOF(parsedIDBuf));
1108 UTimeZoneFormatTimeType parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1109
1110 U_ASSERT(parsedPos < 0);
1111 U_ASSERT(parsedOffset == UNKNOWN_OFFSET);
1112
1113 // ISO 8601
1114 if (parsedPos < maxPos &&
1115 ((evaluated & ISO_Z_STYLE_FLAG) == 0 || (evaluated & ISO_LOCAL_STYLE_FLAG) == 0)) {
1116 tmpPos.setIndex(startIdx);
1117 tmpPos.setErrorIndex(-1);
1118
1119 UBool hasDigitOffset = FALSE;
1120 offset = parseOffsetISO8601(text, tmpPos, FALSE, &hasDigitOffset);
1121 if (tmpPos.getErrorIndex() == -1) {
1122 if (tmpPos.getIndex() == maxPos || hasDigitOffset) {
1123 pos.setIndex(tmpPos.getIndex());
1124 return createTimeZoneForOffset(offset);
1125 }
1126 // Note: When ISO 8601 format contains offset digits, it should not
1127 // collide with other formats. However, ISO 8601 UTC format "Z" (single letter)
1128 // may collide with other names. In this case, we need to evaluate other names.
1129 if (parsedPos < tmpPos.getIndex()) {
1130 parsedOffset = offset;
1131 parsedID.setToBogus();
1132 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1133 parsedPos = tmpPos.getIndex();
1134 U_ASSERT(parsedPos == startIdx + 1); // only when "Z" is used
1135 }
1136 }
1137 }
1138
1139 // Localized GMT format
1140 if (parsedPos < maxPos &&
1141 (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT]) == 0) {
1142 tmpPos.setIndex(startIdx);
1143 tmpPos.setErrorIndex(-1);
1144
1145 UBool hasDigitOffset = FALSE;
1146 offset = parseOffsetLocalizedGMT(text, tmpPos, FALSE, &hasDigitOffset);
1147 if (tmpPos.getErrorIndex() == -1) {
1148 if (tmpPos.getIndex() == maxPos || hasDigitOffset) {
1149 pos.setIndex(tmpPos.getIndex());
1150 return createTimeZoneForOffset(offset);
1151 }
1152 // Evaluate other names - see the comment earlier in this method.
1153 if (parsedPos < tmpPos.getIndex()) {
1154 parsedOffset = offset;
1155 parsedID.setToBogus();
1156 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1157 parsedPos = tmpPos.getIndex();
1158 }
1159 }
1160 }
1161
1162 if (parsedPos < maxPos &&
1163 (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT]) == 0) {
1164 tmpPos.setIndex(startIdx);
1165 tmpPos.setErrorIndex(-1);
1166
1167 UBool hasDigitOffset = FALSE;
1168 offset = parseOffsetLocalizedGMT(text, tmpPos, TRUE, &hasDigitOffset);
1169 if (tmpPos.getErrorIndex() == -1) {
1170 if (tmpPos.getIndex() == maxPos || hasDigitOffset) {
1171 pos.setIndex(tmpPos.getIndex());
1172 return createTimeZoneForOffset(offset);
1173 }
1174 // Evaluate other names - see the comment earlier in this method.
1175 if (parsedPos < tmpPos.getIndex()) {
1176 parsedOffset = offset;
1177 parsedID.setToBogus();
1178 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1179 parsedPos = tmpPos.getIndex();
1180 }
1181 }
1182 }
1183
1184 // When ParseOption.ALL_STYLES is available, we also try to look all possible display names and IDs.
1185 // For example, when style is GENERIC_LONG, "EST" (SPECIFIC_SHORT) is never
1186 // used for America/New_York. With parseAllStyles true, this code parses "EST"
1187 // as America/New_York.
1188
1189 // Note: Adding all possible names into the trie used by the implementation is quite heavy operation,
1190 // which we want to avoid normally (note that we cache the trie, so this is applicable to the
1191 // first time only as long as the cache does not expire).
1192
1193 if (parseOptions & UTZFMT_PARSE_OPTION_ALL_STYLES) {
1194 // Try all specific names and exemplar location names
1195 if (parsedPos < maxPos) {
1196 LocalPointer<TimeZoneNames::MatchInfoCollection> specificMatches(fTimeZoneNames->find(text, startIdx, ALL_SIMPLE_NAME_TYPES, status));
1197 if (U_FAILURE(status)) {
1198 pos.setErrorIndex(startIdx);
1199 return NULL;
1200 }
1201 int32_t specificMatchIdx = -1;
1202 int32_t matchPos = -1;
1203 if (!specificMatches.isNull()) {
1204 for (int32_t i = 0; i < specificMatches->size(); i++) {
1205 if (startIdx + specificMatches->getMatchLengthAt(i) > matchPos) {
1206 specificMatchIdx = i;
1207 matchPos = startIdx + specificMatches->getMatchLengthAt(i);
1208 }
1209 }
1210 }
1211 if (parsedPos < matchPos) {
1212 U_ASSERT(specificMatchIdx >= 0);
1213 parsedPos = matchPos;
1214 getTimeZoneID(specificMatches.getAlias(), specificMatchIdx, parsedID);
1215 parsedTimeType = getTimeType(specificMatches->getNameTypeAt(specificMatchIdx));
1216 parsedOffset = UNKNOWN_OFFSET;
1217 }
1218 }
1219 if (parseTZDBAbbrev && parsedPos < maxPos && (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_SPECIFIC_SHORT]) == 0) {
1220 const TZDBTimeZoneNames *tzdbTimeZoneNames = getTZDBTimeZoneNames(status);
1221 if (U_SUCCESS(status)) {
1222 LocalPointer<TimeZoneNames::MatchInfoCollection> tzdbNameMatches(
1223 tzdbTimeZoneNames->find(text, startIdx, ALL_SIMPLE_NAME_TYPES, status));
1224 if (U_FAILURE(status)) {
1225 pos.setErrorIndex(startIdx);
1226 return NULL;
1227 }
1228 int32_t tzdbNameMatchIdx = -1;
1229 int32_t matchPos = -1;
1230 if (!tzdbNameMatches.isNull()) {
1231 for (int32_t i = 0; i < tzdbNameMatches->size(); i++) {
1232 if (startIdx + tzdbNameMatches->getMatchLengthAt(i) > matchPos) {
1233 tzdbNameMatchIdx = i;
1234 matchPos = startIdx + tzdbNameMatches->getMatchLengthAt(i);
1235 }
1236 }
1237 }
1238 if (parsedPos < matchPos) {
1239 U_ASSERT(tzdbNameMatchIdx >= 0);
1240 parsedPos = matchPos;
1241 getTimeZoneID(tzdbNameMatches.getAlias(), tzdbNameMatchIdx, parsedID);
1242 parsedTimeType = getTimeType(tzdbNameMatches->getNameTypeAt(tzdbNameMatchIdx));
1243 parsedOffset = UNKNOWN_OFFSET;
1244 }
1245 }
1246 }
1247 // Try generic names
1248 if (parsedPos < maxPos) {
1249 int32_t genMatchLen = -1;
1250 UTimeZoneFormatTimeType tt = UTZFMT_TIME_TYPE_UNKNOWN;
1251
1252 const TimeZoneGenericNames *gnames = getTimeZoneGenericNames(status);
1253 if (U_SUCCESS(status)) {
1254 genMatchLen = gnames->findBestMatch(text, startIdx, ALL_GENERIC_NAME_TYPES, tzID, tt, status);
1255 }
1256 if (U_FAILURE(status)) {
1257 pos.setErrorIndex(startIdx);
1258 return NULL;
1259 }
1260
1261 if (genMatchLen > 0 && parsedPos < startIdx + genMatchLen) {
1262 parsedPos = startIdx + genMatchLen;
1263 parsedID.setTo(tzID);
1264 parsedTimeType = tt;
1265 parsedOffset = UNKNOWN_OFFSET;
1266 }
1267 }
1268
1269 // Try time zone ID
1270 if (parsedPos < maxPos && (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_ZONE_ID]) == 0) {
1271 tmpPos.setIndex(startIdx);
1272 tmpPos.setErrorIndex(-1);
1273
1274 parseZoneID(text, tmpPos, tzID);
1275 if (tmpPos.getErrorIndex() == -1 && parsedPos < tmpPos.getIndex()) {
1276 parsedPos = tmpPos.getIndex();
1277 parsedID.setTo(tzID);
1278 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1279 parsedOffset = UNKNOWN_OFFSET;
1280 }
1281 }
1282 // Try short time zone ID
1283 if (parsedPos < maxPos && (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_ZONE_ID]) == 0) {
1284 tmpPos.setIndex(startIdx);
1285 tmpPos.setErrorIndex(-1);
1286
1287 parseShortZoneID(text, tmpPos, tzID);
1288 if (tmpPos.getErrorIndex() == -1 && parsedPos < tmpPos.getIndex()) {
1289 parsedPos = tmpPos.getIndex();
1290 parsedID.setTo(tzID);
1291 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1292 parsedOffset = UNKNOWN_OFFSET;
1293 }
1294 }
1295 }
1296
1297 if (parsedPos > startIdx) {
1298 // Parsed successfully
1299 TimeZone* parsedTZ;
1300 if (parsedID.length() > 0) {
1301 parsedTZ = TimeZone::createTimeZone(parsedID);
1302 } else {
1303 U_ASSERT(parsedOffset != UNKNOWN_OFFSET);
1304 parsedTZ = createTimeZoneForOffset(parsedOffset);
1305 }
1306 if (timeType) {
1307 *timeType = parsedTimeType;
1308 }
1309 pos.setIndex(parsedPos);
1310 return parsedTZ;
1311 }
1312
1313 pos.setErrorIndex(startIdx);
1314 return NULL;
1315 }
1316
1317 void
parseObject(const UnicodeString & source,Formattable & result,ParsePosition & parse_pos) const1318 TimeZoneFormat::parseObject(const UnicodeString& source, Formattable& result,
1319 ParsePosition& parse_pos) const {
1320 result.adoptObject(parse(UTZFMT_STYLE_GENERIC_LOCATION, source, parse_pos, UTZFMT_PARSE_OPTION_ALL_STYLES));
1321 }
1322
1323
1324 // ------------------------------------------------------------------
1325 // Private zone name format/parse implementation
1326
1327 UnicodeString&
formatGeneric(const TimeZone & tz,int32_t genType,UDate date,UnicodeString & name) const1328 TimeZoneFormat::formatGeneric(const TimeZone& tz, int32_t genType, UDate date, UnicodeString& name) const {
1329 UErrorCode status = U_ZERO_ERROR;
1330 const TimeZoneGenericNames* gnames = getTimeZoneGenericNames(status);
1331 if (U_FAILURE(status)) {
1332 name.setToBogus();
1333 return name;
1334 }
1335
1336 if (genType == UTZGNM_LOCATION) {
1337 const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz);
1338 if (canonicalID == NULL) {
1339 name.setToBogus();
1340 return name;
1341 }
1342 return gnames->getGenericLocationName(UnicodeString(TRUE, canonicalID, -1), name);
1343 }
1344 return gnames->getDisplayName(tz, (UTimeZoneGenericNameType)genType, date, name);
1345 }
1346
1347 UnicodeString&
formatSpecific(const TimeZone & tz,UTimeZoneNameType stdType,UTimeZoneNameType dstType,UDate date,UnicodeString & name,UTimeZoneFormatTimeType * timeType) const1348 TimeZoneFormat::formatSpecific(const TimeZone& tz, UTimeZoneNameType stdType, UTimeZoneNameType dstType,
1349 UDate date, UnicodeString& name, UTimeZoneFormatTimeType *timeType) const {
1350 if (fTimeZoneNames == NULL) {
1351 name.setToBogus();
1352 return name;
1353 }
1354
1355 UErrorCode status = U_ZERO_ERROR;
1356 UBool isDaylight = tz.inDaylightTime(date, status);
1357 const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz);
1358
1359 if (U_FAILURE(status) || canonicalID == NULL) {
1360 name.setToBogus();
1361 return name;
1362 }
1363
1364 if (isDaylight) {
1365 fTimeZoneNames->getDisplayName(UnicodeString(TRUE, canonicalID, -1), dstType, date, name);
1366 } else {
1367 fTimeZoneNames->getDisplayName(UnicodeString(TRUE, canonicalID, -1), stdType, date, name);
1368 }
1369
1370 if (timeType && !name.isEmpty()) {
1371 *timeType = isDaylight ? UTZFMT_TIME_TYPE_DAYLIGHT : UTZFMT_TIME_TYPE_STANDARD;
1372 }
1373 return name;
1374 }
1375
1376 const TimeZoneGenericNames*
getTimeZoneGenericNames(UErrorCode & status) const1377 TimeZoneFormat::getTimeZoneGenericNames(UErrorCode& status) const {
1378 if (U_FAILURE(status)) {
1379 return NULL;
1380 }
1381
1382 umtx_lock(&gLock);
1383 if (fTimeZoneGenericNames == NULL) {
1384 TimeZoneFormat *nonConstThis = const_cast<TimeZoneFormat *>(this);
1385 nonConstThis->fTimeZoneGenericNames = TimeZoneGenericNames::createInstance(fLocale, status);
1386 }
1387 umtx_unlock(&gLock);
1388
1389 return fTimeZoneGenericNames;
1390 }
1391
1392 const TZDBTimeZoneNames*
getTZDBTimeZoneNames(UErrorCode & status) const1393 TimeZoneFormat::getTZDBTimeZoneNames(UErrorCode& status) const {
1394 if (U_FAILURE(status)) {
1395 return NULL;
1396 }
1397
1398 umtx_lock(&gLock);
1399 if (fTZDBTimeZoneNames == NULL) {
1400 TZDBTimeZoneNames *tzdbNames = new TZDBTimeZoneNames(fLocale);
1401 if (tzdbNames == NULL) {
1402 status = U_MEMORY_ALLOCATION_ERROR;
1403 } else {
1404 TimeZoneFormat *nonConstThis = const_cast<TimeZoneFormat *>(this);
1405 nonConstThis->fTZDBTimeZoneNames = tzdbNames;
1406 }
1407 }
1408 umtx_unlock(&gLock);
1409
1410 return fTZDBTimeZoneNames;
1411 }
1412
1413 UnicodeString&
formatExemplarLocation(const TimeZone & tz,UnicodeString & name) const1414 TimeZoneFormat::formatExemplarLocation(const TimeZone& tz, UnicodeString& name) const {
1415 UChar locationBuf[64];
1416 UnicodeString location(locationBuf, 0, UPRV_LENGTHOF(locationBuf));
1417 const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz);
1418
1419 if (canonicalID) {
1420 fTimeZoneNames->getExemplarLocationName(UnicodeString(TRUE, canonicalID, -1), location);
1421 }
1422 if (location.length() > 0) {
1423 name.setTo(location);
1424 } else {
1425 // Use "unknown" location
1426 fTimeZoneNames->getExemplarLocationName(UnicodeString(TRUE, UNKNOWN_ZONE_ID, -1), location);
1427 if (location.length() > 0) {
1428 name.setTo(location);
1429 } else {
1430 // last resort
1431 name.setTo(UNKNOWN_LOCATION, -1);
1432 }
1433 }
1434 return name;
1435 }
1436
1437
1438 // ------------------------------------------------------------------
1439 // Zone offset format and parse
1440
1441 UnicodeString&
formatOffsetISO8601Basic(int32_t offset,UBool useUtcIndicator,UBool isShort,UBool ignoreSeconds,UnicodeString & result,UErrorCode & status) const1442 TimeZoneFormat::formatOffsetISO8601Basic(int32_t offset, UBool useUtcIndicator, UBool isShort, UBool ignoreSeconds,
1443 UnicodeString& result, UErrorCode& status) const {
1444 return formatOffsetISO8601(offset, TRUE, useUtcIndicator, isShort, ignoreSeconds, result, status);
1445 }
1446
1447 UnicodeString&
formatOffsetISO8601Extended(int32_t offset,UBool useUtcIndicator,UBool isShort,UBool ignoreSeconds,UnicodeString & result,UErrorCode & status) const1448 TimeZoneFormat::formatOffsetISO8601Extended(int32_t offset, UBool useUtcIndicator, UBool isShort, UBool ignoreSeconds,
1449 UnicodeString& result, UErrorCode& status) const {
1450 return formatOffsetISO8601(offset, FALSE, useUtcIndicator, isShort, ignoreSeconds, result, status);
1451 }
1452
1453 UnicodeString&
formatOffsetLocalizedGMT(int32_t offset,UnicodeString & result,UErrorCode & status) const1454 TimeZoneFormat::formatOffsetLocalizedGMT(int32_t offset, UnicodeString& result, UErrorCode& status) const {
1455 return formatOffsetLocalizedGMT(offset, FALSE, result, status);
1456 }
1457
1458 UnicodeString&
formatOffsetShortLocalizedGMT(int32_t offset,UnicodeString & result,UErrorCode & status) const1459 TimeZoneFormat::formatOffsetShortLocalizedGMT(int32_t offset, UnicodeString& result, UErrorCode& status) const {
1460 return formatOffsetLocalizedGMT(offset, TRUE, result, status);
1461 }
1462
1463 int32_t
parseOffsetISO8601(const UnicodeString & text,ParsePosition & pos) const1464 TimeZoneFormat::parseOffsetISO8601(const UnicodeString& text, ParsePosition& pos) const {
1465 return parseOffsetISO8601(text, pos, FALSE);
1466 }
1467
1468 int32_t
parseOffsetLocalizedGMT(const UnicodeString & text,ParsePosition & pos) const1469 TimeZoneFormat::parseOffsetLocalizedGMT(const UnicodeString& text, ParsePosition& pos) const {
1470 return parseOffsetLocalizedGMT(text, pos, FALSE, NULL);
1471 }
1472
1473 int32_t
parseOffsetShortLocalizedGMT(const UnicodeString & text,ParsePosition & pos) const1474 TimeZoneFormat::parseOffsetShortLocalizedGMT(const UnicodeString& text, ParsePosition& pos) const {
1475 return parseOffsetLocalizedGMT(text, pos, TRUE, NULL);
1476 }
1477
1478 // ------------------------------------------------------------------
1479 // Private zone offset format/parse implementation
1480
1481 UnicodeString&
formatOffsetISO8601(int32_t offset,UBool isBasic,UBool useUtcIndicator,UBool isShort,UBool ignoreSeconds,UnicodeString & result,UErrorCode & status) const1482 TimeZoneFormat::formatOffsetISO8601(int32_t offset, UBool isBasic, UBool useUtcIndicator,
1483 UBool isShort, UBool ignoreSeconds, UnicodeString& result, UErrorCode& status) const {
1484 if (U_FAILURE(status)) {
1485 result.setToBogus();
1486 return result;
1487 }
1488 int32_t absOffset = offset < 0 ? -offset : offset;
1489 if (useUtcIndicator && (absOffset < MILLIS_PER_SECOND || (ignoreSeconds && absOffset < MILLIS_PER_MINUTE))) {
1490 result.setTo(ISO8601_UTC);
1491 return result;
1492 }
1493
1494 OffsetFields minFields = isShort ? FIELDS_H : FIELDS_HM;
1495 OffsetFields maxFields = ignoreSeconds ? FIELDS_HM : FIELDS_HMS;
1496 UChar sep = isBasic ? 0 : ISO8601_SEP;
1497
1498 // Note: FIELDS_HMS as maxFields is a CLDR/ICU extension. ISO 8601 specification does
1499 // not support seconds field.
1500
1501 if (absOffset >= MAX_OFFSET) {
1502 result.setToBogus();
1503 status = U_ILLEGAL_ARGUMENT_ERROR;
1504 return result;
1505 }
1506
1507 int fields[3];
1508 fields[0] = absOffset / MILLIS_PER_HOUR;
1509 absOffset = absOffset % MILLIS_PER_HOUR;
1510 fields[1] = absOffset / MILLIS_PER_MINUTE;
1511 absOffset = absOffset % MILLIS_PER_MINUTE;
1512 fields[2] = absOffset / MILLIS_PER_SECOND;
1513
1514 U_ASSERT(fields[0] >= 0 && fields[0] <= MAX_OFFSET_HOUR);
1515 U_ASSERT(fields[1] >= 0 && fields[1] <= MAX_OFFSET_MINUTE);
1516 U_ASSERT(fields[2] >= 0 && fields[2] <= MAX_OFFSET_SECOND);
1517
1518 int32_t lastIdx = maxFields;
1519 while (lastIdx > minFields) {
1520 if (fields[lastIdx] != 0) {
1521 break;
1522 }
1523 lastIdx--;
1524 }
1525
1526 UChar sign = PLUS;
1527 if (offset < 0) {
1528 // if all output fields are 0s, do not use negative sign
1529 for (int32_t idx = 0; idx <= lastIdx; idx++) {
1530 if (fields[idx] != 0) {
1531 sign = MINUS;
1532 break;
1533 }
1534 }
1535 }
1536 result.setTo(sign);
1537
1538 for (int32_t idx = 0; idx <= lastIdx; idx++) {
1539 if (sep && idx != 0) {
1540 result.append(sep);
1541 }
1542 result.append((UChar)(0x0030 + fields[idx]/10));
1543 result.append((UChar)(0x0030 + fields[idx]%10));
1544 }
1545
1546 return result;
1547 }
1548
1549 UnicodeString&
formatOffsetLocalizedGMT(int32_t offset,UBool isShort,UnicodeString & result,UErrorCode & status) const1550 TimeZoneFormat::formatOffsetLocalizedGMT(int32_t offset, UBool isShort, UnicodeString& result, UErrorCode& status) const {
1551 if (U_FAILURE(status)) {
1552 result.setToBogus();
1553 return result;
1554 }
1555 if (offset <= -MAX_OFFSET || offset >= MAX_OFFSET) {
1556 result.setToBogus();
1557 status = U_ILLEGAL_ARGUMENT_ERROR;
1558 return result;
1559 }
1560
1561 if (offset == 0) {
1562 result.setTo(fGMTZeroFormat);
1563 return result;
1564 }
1565
1566 UBool positive = TRUE;
1567 if (offset < 0) {
1568 offset = -offset;
1569 positive = FALSE;
1570 }
1571
1572 int32_t offsetH = offset / MILLIS_PER_HOUR;
1573 offset = offset % MILLIS_PER_HOUR;
1574 int32_t offsetM = offset / MILLIS_PER_MINUTE;
1575 offset = offset % MILLIS_PER_MINUTE;
1576 int32_t offsetS = offset / MILLIS_PER_SECOND;
1577
1578 U_ASSERT(offsetH <= MAX_OFFSET_HOUR && offsetM <= MAX_OFFSET_MINUTE && offsetS <= MAX_OFFSET_SECOND);
1579
1580 const UVector* offsetPatternItems = NULL;
1581 if (positive) {
1582 if (offsetS != 0) {
1583 offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_POSITIVE_HMS];
1584 } else if (offsetM != 0 || !isShort) {
1585 offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_POSITIVE_HM];
1586 } else {
1587 offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_POSITIVE_H];
1588 }
1589 } else {
1590 if (offsetS != 0) {
1591 offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_NEGATIVE_HMS];
1592 } else if (offsetM != 0 || !isShort) {
1593 offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_NEGATIVE_HM];
1594 } else {
1595 offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_NEGATIVE_H];
1596 }
1597 }
1598
1599 U_ASSERT(offsetPatternItems != NULL);
1600
1601 // Building the GMT format string
1602 result.setTo(fGMTPatternPrefix);
1603
1604 for (int32_t i = 0; i < offsetPatternItems->size(); i++) {
1605 const GMTOffsetField* item = (GMTOffsetField*)offsetPatternItems->elementAt(i);
1606 GMTOffsetField::FieldType type = item->getType();
1607
1608 switch (type) {
1609 case GMTOffsetField::TEXT:
1610 result.append(item->getPatternText(), -1);
1611 break;
1612
1613 case GMTOffsetField::HOUR:
1614 appendOffsetDigits(result, offsetH, (isShort ? 1 : 2));
1615 break;
1616
1617 case GMTOffsetField::MINUTE:
1618 appendOffsetDigits(result, offsetM, 2);
1619 break;
1620
1621 case GMTOffsetField::SECOND:
1622 appendOffsetDigits(result, offsetS, 2);
1623 break;
1624 }
1625 }
1626
1627 result.append(fGMTPatternSuffix);
1628 return result;
1629 }
1630
1631 int32_t
parseOffsetISO8601(const UnicodeString & text,ParsePosition & pos,UBool extendedOnly,UBool * hasDigitOffset) const1632 TimeZoneFormat::parseOffsetISO8601(const UnicodeString& text, ParsePosition& pos, UBool extendedOnly, UBool* hasDigitOffset /* = NULL */) const {
1633 if (hasDigitOffset) {
1634 *hasDigitOffset = FALSE;
1635 }
1636 int32_t start = pos.getIndex();
1637 if (start >= text.length()) {
1638 pos.setErrorIndex(start);
1639 return 0;
1640 }
1641
1642 UChar firstChar = text.charAt(start);
1643 if (firstChar == ISO8601_UTC || firstChar == (UChar)(ISO8601_UTC + 0x20)) {
1644 // "Z" (or "z") - indicates UTC
1645 pos.setIndex(start + 1);
1646 return 0;
1647 }
1648
1649 int32_t sign = 1;
1650 if (firstChar == PLUS) {
1651 sign = 1;
1652 } else if (firstChar == MINUS) {
1653 sign = -1;
1654 } else {
1655 // Not an ISO 8601 offset string
1656 pos.setErrorIndex(start);
1657 return 0;
1658 }
1659 ParsePosition posOffset(start + 1);
1660 int32_t offset = parseAsciiOffsetFields(text, posOffset, ISO8601_SEP, FIELDS_H, FIELDS_HMS);
1661 if (posOffset.getErrorIndex() == -1 && !extendedOnly && (posOffset.getIndex() - start <= 3)) {
1662 // If the text is successfully parsed as extended format with the options above, it can be also parsed
1663 // as basic format. For example, "0230" can be parsed as offset 2:00 (only first digits are valid for
1664 // extended format), but it can be parsed as offset 2:30 with basic format. We use longer result.
1665 ParsePosition posBasic(start + 1);
1666 int32_t tmpOffset = parseAbuttingAsciiOffsetFields(text, posBasic, FIELDS_H, FIELDS_HMS, FALSE);
1667 if (posBasic.getErrorIndex() == -1 && posBasic.getIndex() > posOffset.getIndex()) {
1668 offset = tmpOffset;
1669 posOffset.setIndex(posBasic.getIndex());
1670 }
1671 }
1672
1673 if (posOffset.getErrorIndex() != -1) {
1674 pos.setErrorIndex(start);
1675 return 0;
1676 }
1677
1678 pos.setIndex(posOffset.getIndex());
1679 if (hasDigitOffset) {
1680 *hasDigitOffset = TRUE;
1681 }
1682 return sign * offset;
1683 }
1684
1685 int32_t
parseOffsetLocalizedGMT(const UnicodeString & text,ParsePosition & pos,UBool isShort,UBool * hasDigitOffset) const1686 TimeZoneFormat::parseOffsetLocalizedGMT(const UnicodeString& text, ParsePosition& pos, UBool isShort, UBool* hasDigitOffset) const {
1687 int32_t start = pos.getIndex();
1688 int32_t offset = 0;
1689 int32_t parsedLength = 0;
1690
1691 if (hasDigitOffset) {
1692 *hasDigitOffset = FALSE;
1693 }
1694
1695 offset = parseOffsetLocalizedGMTPattern(text, start, isShort, parsedLength);
1696
1697 // For now, parseOffsetLocalizedGMTPattern handles both long and short
1698 // formats, no matter isShort is true or false. This might be changed in future
1699 // when strict parsing is necessary, or different set of patterns are used for
1700 // short/long formats.
1701 #if 0
1702 if (parsedLength == 0) {
1703 offset = parseOffsetLocalizedGMTPattern(text, start, !isShort, parsedLength);
1704 }
1705 #endif
1706
1707 if (parsedLength > 0) {
1708 if (hasDigitOffset) {
1709 *hasDigitOffset = TRUE;
1710 }
1711 pos.setIndex(start + parsedLength);
1712 return offset;
1713 }
1714
1715 // Try the default patterns
1716 offset = parseOffsetDefaultLocalizedGMT(text, start, parsedLength);
1717 if (parsedLength > 0) {
1718 if (hasDigitOffset) {
1719 *hasDigitOffset = TRUE;
1720 }
1721 pos.setIndex(start + parsedLength);
1722 return offset;
1723 }
1724
1725 // Check if this is a GMT zero format
1726 if (text.caseCompare(start, fGMTZeroFormat.length(), fGMTZeroFormat, 0) == 0) {
1727 pos.setIndex(start + fGMTZeroFormat.length());
1728 return 0;
1729 }
1730
1731 // Check if this is a default GMT zero format
1732 for (int32_t i = 0; ALT_GMT_STRINGS[i][0] != 0; i++) {
1733 const UChar* defGMTZero = ALT_GMT_STRINGS[i];
1734 int32_t defGMTZeroLen = u_strlen(defGMTZero);
1735 if (text.caseCompare(start, defGMTZeroLen, defGMTZero, 0) == 0) {
1736 pos.setIndex(start + defGMTZeroLen);
1737 return 0;
1738 }
1739 }
1740
1741 // Nothing matched
1742 pos.setErrorIndex(start);
1743 return 0;
1744 }
1745
1746 int32_t
parseOffsetLocalizedGMTPattern(const UnicodeString & text,int32_t start,UBool,int32_t & parsedLen) const1747 TimeZoneFormat::parseOffsetLocalizedGMTPattern(const UnicodeString& text, int32_t start, UBool /*isShort*/, int32_t& parsedLen) const {
1748 int32_t idx = start;
1749 int32_t offset = 0;
1750 UBool parsed = FALSE;
1751
1752 do {
1753 // Prefix part
1754 int32_t len = fGMTPatternPrefix.length();
1755 if (len > 0 && text.caseCompare(idx, len, fGMTPatternPrefix, 0) != 0) {
1756 // prefix match failed
1757 break;
1758 }
1759 idx += len;
1760
1761 // Offset part
1762 offset = parseOffsetFields(text, idx, FALSE, len);
1763 if (len == 0) {
1764 // offset field match failed
1765 break;
1766 }
1767 idx += len;
1768
1769 len = fGMTPatternSuffix.length();
1770 if (len > 0 && text.caseCompare(idx, len, fGMTPatternSuffix, 0) != 0) {
1771 // no suffix match
1772 break;
1773 }
1774 idx += len;
1775 parsed = TRUE;
1776 } while (FALSE);
1777
1778 parsedLen = parsed ? idx - start : 0;
1779 return offset;
1780 }
1781
1782 int32_t
parseOffsetFields(const UnicodeString & text,int32_t start,UBool,int32_t & parsedLen) const1783 TimeZoneFormat::parseOffsetFields(const UnicodeString& text, int32_t start, UBool /*isShort*/, int32_t& parsedLen) const {
1784 int32_t outLen = 0;
1785 int32_t offset = 0;
1786 int32_t sign = 1;
1787
1788 parsedLen = 0;
1789
1790 int32_t offsetH, offsetM, offsetS;
1791 offsetH = offsetM = offsetS = 0;
1792
1793 for (int32_t patidx = 0; PARSE_GMT_OFFSET_TYPES[patidx] >= 0; patidx++) {
1794 int32_t gmtPatType = PARSE_GMT_OFFSET_TYPES[patidx];
1795 UVector* items = fGMTOffsetPatternItems[gmtPatType];
1796 U_ASSERT(items != NULL);
1797
1798 outLen = parseOffsetFieldsWithPattern(text, start, items, FALSE, offsetH, offsetM, offsetS);
1799 if (outLen > 0) {
1800 sign = (gmtPatType == UTZFMT_PAT_POSITIVE_H || gmtPatType == UTZFMT_PAT_POSITIVE_HM || gmtPatType == UTZFMT_PAT_POSITIVE_HMS) ?
1801 1 : -1;
1802 break;
1803 }
1804 }
1805
1806 if (outLen > 0 && fAbuttingOffsetHoursAndMinutes) {
1807 // When hours field is sabutting minutes field,
1808 // the parse result above may not be appropriate.
1809 // For example, "01020" is parsed as 01:02: above,
1810 // but it should be parsed as 00:10:20.
1811 int32_t tmpLen = 0;
1812 int32_t tmpSign = 1;
1813 int32_t tmpH, tmpM, tmpS;
1814
1815 for (int32_t patidx = 0; PARSE_GMT_OFFSET_TYPES[patidx] >= 0; patidx++) {
1816 int32_t gmtPatType = PARSE_GMT_OFFSET_TYPES[patidx];
1817 UVector* items = fGMTOffsetPatternItems[gmtPatType];
1818 U_ASSERT(items != NULL);
1819
1820 // forcing parse to use single hour digit
1821 tmpLen = parseOffsetFieldsWithPattern(text, start, items, TRUE, tmpH, tmpM, tmpS);
1822 if (tmpLen > 0) {
1823 tmpSign = (gmtPatType == UTZFMT_PAT_POSITIVE_H || gmtPatType == UTZFMT_PAT_POSITIVE_HM || gmtPatType == UTZFMT_PAT_POSITIVE_HMS) ?
1824 1 : -1;
1825 break;
1826 }
1827 }
1828 if (tmpLen > outLen) {
1829 // Better parse result with single hour digit
1830 outLen = tmpLen;
1831 sign = tmpSign;
1832 offsetH = tmpH;
1833 offsetM = tmpM;
1834 offsetS = tmpS;
1835 }
1836 }
1837
1838 if (outLen > 0) {
1839 offset = ((((offsetH * 60) + offsetM) * 60) + offsetS) * 1000 * sign;
1840 parsedLen = outLen;
1841 }
1842
1843 return offset;
1844 }
1845
1846 int32_t
parseOffsetFieldsWithPattern(const UnicodeString & text,int32_t start,UVector * patternItems,UBool forceSingleHourDigit,int32_t & hour,int32_t & min,int32_t & sec) const1847 TimeZoneFormat::parseOffsetFieldsWithPattern(const UnicodeString& text, int32_t start,
1848 UVector* patternItems, UBool forceSingleHourDigit, int32_t& hour, int32_t& min, int32_t& sec) const {
1849 UBool failed = FALSE;
1850 int32_t offsetH, offsetM, offsetS;
1851 offsetH = offsetM = offsetS = 0;
1852 int32_t idx = start;
1853
1854 for (int32_t i = 0; i < patternItems->size(); i++) {
1855 int32_t len = 0;
1856 const GMTOffsetField* field = (const GMTOffsetField*)patternItems->elementAt(i);
1857 GMTOffsetField::FieldType fieldType = field->getType();
1858 if (fieldType == GMTOffsetField::TEXT) {
1859 const UChar* patStr = field->getPatternText();
1860 len = u_strlen(patStr);
1861 if (text.caseCompare(idx, len, patStr, 0) != 0) {
1862 failed = TRUE;
1863 break;
1864 }
1865 idx += len;
1866 } else {
1867 if (fieldType == GMTOffsetField::HOUR) {
1868 uint8_t maxDigits = forceSingleHourDigit ? 1 : 2;
1869 offsetH = parseOffsetFieldWithLocalizedDigits(text, idx, 1, maxDigits, 0, MAX_OFFSET_HOUR, len);
1870 } else if (fieldType == GMTOffsetField::MINUTE) {
1871 offsetM = parseOffsetFieldWithLocalizedDigits(text, idx, 2, 2, 0, MAX_OFFSET_MINUTE, len);
1872 } else if (fieldType == GMTOffsetField::SECOND) {
1873 offsetS = parseOffsetFieldWithLocalizedDigits(text, idx, 2, 2, 0, MAX_OFFSET_SECOND, len);
1874 }
1875
1876 if (len == 0) {
1877 failed = TRUE;
1878 break;
1879 }
1880 idx += len;
1881 }
1882 }
1883
1884 if (failed) {
1885 hour = min = sec = 0;
1886 return 0;
1887 }
1888
1889 hour = offsetH;
1890 min = offsetM;
1891 sec = offsetS;
1892
1893 return idx - start;
1894 }
1895
1896 int32_t
parseAbuttingOffsetFields(const UnicodeString & text,int32_t start,int32_t & parsedLen) const1897 TimeZoneFormat::parseAbuttingOffsetFields(const UnicodeString& text, int32_t start, int32_t& parsedLen) const {
1898 int32_t digits[MAX_OFFSET_DIGITS];
1899 int32_t parsed[MAX_OFFSET_DIGITS]; // accumulative offsets
1900
1901 // Parse digits into int[]
1902 int32_t idx = start;
1903 int32_t len = 0;
1904 int32_t numDigits = 0;
1905 for (int32_t i = 0; i < MAX_OFFSET_DIGITS; i++) {
1906 digits[i] = parseSingleLocalizedDigit(text, idx, len);
1907 if (digits[i] < 0) {
1908 break;
1909 }
1910 idx += len;
1911 parsed[i] = idx - start;
1912 numDigits++;
1913 }
1914
1915 if (numDigits == 0) {
1916 parsedLen = 0;
1917 return 0;
1918 }
1919
1920 int32_t offset = 0;
1921 while (numDigits > 0) {
1922 int32_t hour = 0;
1923 int32_t min = 0;
1924 int32_t sec = 0;
1925
1926 U_ASSERT(numDigits > 0 && numDigits <= MAX_OFFSET_DIGITS);
1927 switch (numDigits) {
1928 case 1: // H
1929 hour = digits[0];
1930 break;
1931 case 2: // HH
1932 hour = digits[0] * 10 + digits[1];
1933 break;
1934 case 3: // Hmm
1935 hour = digits[0];
1936 min = digits[1] * 10 + digits[2];
1937 break;
1938 case 4: // HHmm
1939 hour = digits[0] * 10 + digits[1];
1940 min = digits[2] * 10 + digits[3];
1941 break;
1942 case 5: // Hmmss
1943 hour = digits[0];
1944 min = digits[1] * 10 + digits[2];
1945 sec = digits[3] * 10 + digits[4];
1946 break;
1947 case 6: // HHmmss
1948 hour = digits[0] * 10 + digits[1];
1949 min = digits[2] * 10 + digits[3];
1950 sec = digits[4] * 10 + digits[5];
1951 break;
1952 }
1953 if (hour <= MAX_OFFSET_HOUR && min <= MAX_OFFSET_MINUTE && sec <= MAX_OFFSET_SECOND) {
1954 // found a valid combination
1955 offset = hour * MILLIS_PER_HOUR + min * MILLIS_PER_MINUTE + sec * MILLIS_PER_SECOND;
1956 parsedLen = parsed[numDigits - 1];
1957 break;
1958 }
1959 numDigits--;
1960 }
1961 return offset;
1962 }
1963
1964 int32_t
parseOffsetDefaultLocalizedGMT(const UnicodeString & text,int start,int32_t & parsedLen) const1965 TimeZoneFormat::parseOffsetDefaultLocalizedGMT(const UnicodeString& text, int start, int32_t& parsedLen) const {
1966 int32_t idx = start;
1967 int32_t offset = 0;
1968 int32_t parsed = 0;
1969
1970 do {
1971 // check global default GMT alternatives
1972 int32_t gmtLen = 0;
1973
1974 for (int32_t i = 0; ALT_GMT_STRINGS[i][0] != 0; i++) {
1975 const UChar* gmt = ALT_GMT_STRINGS[i];
1976 int32_t len = u_strlen(gmt);
1977 if (text.caseCompare(start, len, gmt, 0) == 0) {
1978 gmtLen = len;
1979 break;
1980 }
1981 }
1982 if (gmtLen == 0) {
1983 break;
1984 }
1985 idx += gmtLen;
1986
1987 // offset needs a sign char and a digit at minimum
1988 if (idx + 1 >= text.length()) {
1989 break;
1990 }
1991
1992 // parse sign
1993 int32_t sign = 1;
1994 UChar c = text.charAt(idx);
1995 if (c == PLUS) {
1996 sign = 1;
1997 } else if (c == MINUS) {
1998 sign = -1;
1999 } else {
2000 break;
2001 }
2002 idx++;
2003
2004 // offset part
2005 // try the default pattern with the separator first
2006 int32_t lenWithSep = 0;
2007 int32_t offsetWithSep = parseDefaultOffsetFields(text, idx, DEFAULT_GMT_OFFSET_SEP, lenWithSep);
2008 if (lenWithSep == text.length() - idx) {
2009 // maximum match
2010 offset = offsetWithSep * sign;
2011 idx += lenWithSep;
2012 } else {
2013 // try abutting field pattern
2014 int32_t lenAbut = 0;
2015 int32_t offsetAbut = parseAbuttingOffsetFields(text, idx, lenAbut);
2016
2017 if (lenWithSep > lenAbut) {
2018 offset = offsetWithSep * sign;
2019 idx += lenWithSep;
2020 } else {
2021 offset = offsetAbut * sign;
2022 idx += lenAbut;
2023 }
2024 }
2025 parsed = idx - start;
2026 } while (false);
2027
2028 parsedLen = parsed;
2029 return offset;
2030 }
2031
2032 int32_t
parseDefaultOffsetFields(const UnicodeString & text,int32_t start,UChar separator,int32_t & parsedLen) const2033 TimeZoneFormat::parseDefaultOffsetFields(const UnicodeString& text, int32_t start, UChar separator, int32_t& parsedLen) const {
2034 int32_t max = text.length();
2035 int32_t idx = start;
2036 int32_t len = 0;
2037 int32_t hour = 0, min = 0, sec = 0;
2038
2039 parsedLen = 0;
2040
2041 do {
2042 hour = parseOffsetFieldWithLocalizedDigits(text, idx, 1, 2, 0, MAX_OFFSET_HOUR, len);
2043 if (len == 0) {
2044 break;
2045 }
2046 idx += len;
2047
2048 if (idx + 1 < max && text.charAt(idx) == separator) {
2049 min = parseOffsetFieldWithLocalizedDigits(text, idx + 1, 2, 2, 0, MAX_OFFSET_MINUTE, len);
2050 if (len == 0) {
2051 break;
2052 }
2053 idx += (1 + len);
2054
2055 if (idx + 1 < max && text.charAt(idx) == separator) {
2056 sec = parseOffsetFieldWithLocalizedDigits(text, idx + 1, 2, 2, 0, MAX_OFFSET_SECOND, len);
2057 if (len == 0) {
2058 break;
2059 }
2060 idx += (1 + len);
2061 }
2062 }
2063 } while (FALSE);
2064
2065 if (idx == start) {
2066 return 0;
2067 }
2068
2069 parsedLen = idx - start;
2070 return hour * MILLIS_PER_HOUR + min * MILLIS_PER_MINUTE + sec * MILLIS_PER_SECOND;
2071 }
2072
2073 int32_t
parseOffsetFieldWithLocalizedDigits(const UnicodeString & text,int32_t start,uint8_t minDigits,uint8_t maxDigits,uint16_t minVal,uint16_t maxVal,int32_t & parsedLen) const2074 TimeZoneFormat::parseOffsetFieldWithLocalizedDigits(const UnicodeString& text, int32_t start, uint8_t minDigits, uint8_t maxDigits, uint16_t minVal, uint16_t maxVal, int32_t& parsedLen) const {
2075 parsedLen = 0;
2076
2077 int32_t decVal = 0;
2078 int32_t numDigits = 0;
2079 int32_t idx = start;
2080 int32_t digitLen = 0;
2081
2082 while (idx < text.length() && numDigits < maxDigits) {
2083 int32_t digit = parseSingleLocalizedDigit(text, idx, digitLen);
2084 if (digit < 0) {
2085 break;
2086 }
2087 int32_t tmpVal = decVal * 10 + digit;
2088 if (tmpVal > maxVal) {
2089 break;
2090 }
2091 decVal = tmpVal;
2092 numDigits++;
2093 idx += digitLen;
2094 }
2095
2096 // Note: maxVal is checked in the while loop
2097 if (numDigits < minDigits || decVal < minVal) {
2098 decVal = -1;
2099 numDigits = 0;
2100 } else {
2101 parsedLen = idx - start;
2102 }
2103
2104 return decVal;
2105 }
2106
2107 int32_t
parseSingleLocalizedDigit(const UnicodeString & text,int32_t start,int32_t & len) const2108 TimeZoneFormat::parseSingleLocalizedDigit(const UnicodeString& text, int32_t start, int32_t& len) const {
2109 int32_t digit = -1;
2110 len = 0;
2111 if (start < text.length()) {
2112 UChar32 cp = text.char32At(start);
2113
2114 // First, try digits configured for this instance
2115 for (int32_t i = 0; i < 10; i++) {
2116 if (cp == fGMTOffsetDigits[i]) {
2117 digit = i;
2118 break;
2119 }
2120 }
2121 // If failed, check if this is a Unicode digit
2122 if (digit < 0) {
2123 int32_t tmp = u_charDigitValue(cp);
2124 digit = (tmp >= 0 && tmp <= 9) ? tmp : -1;
2125 }
2126
2127 if (digit >= 0) {
2128 int32_t next = text.moveIndex32(start, 1);
2129 len = next - start;
2130 }
2131 }
2132 return digit;
2133 }
2134
2135 UnicodeString&
formatOffsetWithAsciiDigits(int32_t offset,UChar sep,OffsetFields minFields,OffsetFields maxFields,UnicodeString & result)2136 TimeZoneFormat::formatOffsetWithAsciiDigits(int32_t offset, UChar sep, OffsetFields minFields, OffsetFields maxFields, UnicodeString& result) {
2137 U_ASSERT(maxFields >= minFields);
2138 U_ASSERT(offset > -MAX_OFFSET && offset < MAX_OFFSET);
2139
2140 UChar sign = PLUS;
2141 if (offset < 0) {
2142 sign = MINUS;
2143 offset = -offset;
2144 }
2145 result.setTo(sign);
2146
2147 int fields[3];
2148 fields[0] = offset / MILLIS_PER_HOUR;
2149 offset = offset % MILLIS_PER_HOUR;
2150 fields[1] = offset / MILLIS_PER_MINUTE;
2151 offset = offset % MILLIS_PER_MINUTE;
2152 fields[2] = offset / MILLIS_PER_SECOND;
2153
2154 U_ASSERT(fields[0] >= 0 && fields[0] <= MAX_OFFSET_HOUR);
2155 U_ASSERT(fields[1] >= 0 && fields[1] <= MAX_OFFSET_MINUTE);
2156 U_ASSERT(fields[2] >= 0 && fields[2] <= MAX_OFFSET_SECOND);
2157
2158 int32_t lastIdx = maxFields;
2159 while (lastIdx > minFields) {
2160 if (fields[lastIdx] != 0) {
2161 break;
2162 }
2163 lastIdx--;
2164 }
2165
2166 for (int32_t idx = 0; idx <= lastIdx; idx++) {
2167 if (sep && idx != 0) {
2168 result.append(sep);
2169 }
2170 result.append((UChar)(0x0030 + fields[idx]/10));
2171 result.append((UChar)(0x0030 + fields[idx]%10));
2172 }
2173
2174 return result;
2175 }
2176
2177 int32_t
parseAbuttingAsciiOffsetFields(const UnicodeString & text,ParsePosition & pos,OffsetFields minFields,OffsetFields maxFields,UBool fixedHourWidth)2178 TimeZoneFormat::parseAbuttingAsciiOffsetFields(const UnicodeString& text, ParsePosition& pos, OffsetFields minFields, OffsetFields maxFields, UBool fixedHourWidth) {
2179 int32_t start = pos.getIndex();
2180
2181 int32_t minDigits = 2 * (minFields + 1) - (fixedHourWidth ? 0 : 1);
2182 int32_t maxDigits = 2 * (maxFields + 1);
2183
2184 U_ASSERT(maxDigits <= MAX_OFFSET_DIGITS);
2185
2186 int32_t digits[MAX_OFFSET_DIGITS] = {};
2187 int32_t numDigits = 0;
2188 int32_t idx = start;
2189 while (numDigits < maxDigits && idx < text.length()) {
2190 UChar uch = text.charAt(idx);
2191 int32_t digit = DIGIT_VAL(uch);
2192 if (digit < 0) {
2193 break;
2194 }
2195 digits[numDigits] = digit;
2196 numDigits++;
2197 idx++;
2198 }
2199
2200 if (fixedHourWidth && (numDigits & 1)) {
2201 // Fixed digits, so the number of digits must be even number. Truncating.
2202 numDigits--;
2203 }
2204
2205 if (numDigits < minDigits) {
2206 pos.setErrorIndex(start);
2207 return 0;
2208 }
2209
2210 int32_t hour = 0, min = 0, sec = 0;
2211 UBool bParsed = FALSE;
2212 while (numDigits >= minDigits) {
2213 switch (numDigits) {
2214 case 1: //H
2215 hour = digits[0];
2216 break;
2217 case 2: //HH
2218 hour = digits[0] * 10 + digits[1];
2219 break;
2220 case 3: //Hmm
2221 hour = digits[0];
2222 min = digits[1] * 10 + digits[2];
2223 break;
2224 case 4: //HHmm
2225 hour = digits[0] * 10 + digits[1];
2226 min = digits[2] * 10 + digits[3];
2227 break;
2228 case 5: //Hmmss
2229 hour = digits[0];
2230 min = digits[1] * 10 + digits[2];
2231 sec = digits[3] * 10 + digits[4];
2232 break;
2233 case 6: //HHmmss
2234 hour = digits[0] * 10 + digits[1];
2235 min = digits[2] * 10 + digits[3];
2236 sec = digits[4] * 10 + digits[5];
2237 break;
2238 }
2239
2240 if (hour <= MAX_OFFSET_HOUR && min <= MAX_OFFSET_MINUTE && sec <= MAX_OFFSET_SECOND) {
2241 // Successfully parsed
2242 bParsed = true;
2243 break;
2244 }
2245
2246 // Truncating
2247 numDigits -= (fixedHourWidth ? 2 : 1);
2248 hour = min = sec = 0;
2249 }
2250
2251 if (!bParsed) {
2252 pos.setErrorIndex(start);
2253 return 0;
2254 }
2255 pos.setIndex(start + numDigits);
2256 return ((((hour * 60) + min) * 60) + sec) * 1000;
2257 }
2258
2259 int32_t
parseAsciiOffsetFields(const UnicodeString & text,ParsePosition & pos,UChar sep,OffsetFields minFields,OffsetFields maxFields)2260 TimeZoneFormat::parseAsciiOffsetFields(const UnicodeString& text, ParsePosition& pos, UChar sep, OffsetFields minFields, OffsetFields maxFields) {
2261 int32_t start = pos.getIndex();
2262 int32_t fieldVal[] = {0, 0, 0};
2263 int32_t fieldLen[] = {0, -1, -1};
2264 for (int32_t idx = start, fieldIdx = 0; idx < text.length() && fieldIdx <= maxFields; idx++) {
2265 UChar c = text.charAt(idx);
2266 if (c == sep) {
2267 if (fieldIdx == 0) {
2268 if (fieldLen[0] == 0) {
2269 // no hours field
2270 break;
2271 }
2272 // 1 digit hour, move to next field
2273 } else {
2274 if (fieldLen[fieldIdx] != -1) {
2275 // premature minute or seconds field
2276 break;
2277 }
2278 fieldLen[fieldIdx] = 0;
2279 }
2280 continue;
2281 } else if (fieldLen[fieldIdx] == -1) {
2282 // no separator after 2 digit field
2283 break;
2284 }
2285 int32_t digit = DIGIT_VAL(c);
2286 if (digit < 0) {
2287 // not a digit
2288 break;
2289 }
2290 fieldVal[fieldIdx] = fieldVal[fieldIdx] * 10 + digit;
2291 fieldLen[fieldIdx]++;
2292 if (fieldLen[fieldIdx] >= 2) {
2293 // parsed 2 digits, move to next field
2294 fieldIdx++;
2295 }
2296 }
2297
2298 int32_t offset = 0;
2299 int32_t parsedLen = 0;
2300 int32_t parsedFields = -1;
2301 do {
2302 // hour
2303 if (fieldLen[0] == 0) {
2304 break;
2305 }
2306 if (fieldVal[0] > MAX_OFFSET_HOUR) {
2307 offset = (fieldVal[0] / 10) * MILLIS_PER_HOUR;
2308 parsedFields = FIELDS_H;
2309 parsedLen = 1;
2310 break;
2311 }
2312 offset = fieldVal[0] * MILLIS_PER_HOUR;
2313 parsedLen = fieldLen[0];
2314 parsedFields = FIELDS_H;
2315
2316 // minute
2317 if (fieldLen[1] != 2 || fieldVal[1] > MAX_OFFSET_MINUTE) {
2318 break;
2319 }
2320 offset += fieldVal[1] * MILLIS_PER_MINUTE;
2321 parsedLen += (1 + fieldLen[1]);
2322 parsedFields = FIELDS_HM;
2323
2324 // second
2325 if (fieldLen[2] != 2 || fieldVal[2] > MAX_OFFSET_SECOND) {
2326 break;
2327 }
2328 offset += fieldVal[2] * MILLIS_PER_SECOND;
2329 parsedLen += (1 + fieldLen[2]);
2330 parsedFields = FIELDS_HMS;
2331 } while (false);
2332
2333 if (parsedFields < minFields) {
2334 pos.setErrorIndex(start);
2335 return 0;
2336 }
2337
2338 pos.setIndex(start + parsedLen);
2339 return offset;
2340 }
2341
2342 void
appendOffsetDigits(UnicodeString & buf,int32_t n,uint8_t minDigits) const2343 TimeZoneFormat::appendOffsetDigits(UnicodeString& buf, int32_t n, uint8_t minDigits) const {
2344 U_ASSERT(n >= 0 && n < 60);
2345 int32_t numDigits = n >= 10 ? 2 : 1;
2346 for (int32_t i = 0; i < minDigits - numDigits; i++) {
2347 buf.append(fGMTOffsetDigits[0]);
2348 }
2349 if (numDigits == 2) {
2350 buf.append(fGMTOffsetDigits[n / 10]);
2351 }
2352 buf.append(fGMTOffsetDigits[n % 10]);
2353 }
2354
2355 // ------------------------------------------------------------------
2356 // Private misc
2357 void
initGMTPattern(const UnicodeString & gmtPattern,UErrorCode & status)2358 TimeZoneFormat::initGMTPattern(const UnicodeString& gmtPattern, UErrorCode& status) {
2359 if (U_FAILURE(status)) {
2360 return;
2361 }
2362 // This implementation not perfect, but sufficient practically.
2363 int32_t idx = gmtPattern.indexOf(ARG0, ARG0_LEN, 0);
2364 if (idx < 0) {
2365 status = U_ILLEGAL_ARGUMENT_ERROR;
2366 return;
2367 }
2368 fGMTPattern.setTo(gmtPattern);
2369 unquote(gmtPattern.tempSubString(0, idx), fGMTPatternPrefix);
2370 unquote(gmtPattern.tempSubString(idx + ARG0_LEN), fGMTPatternSuffix);
2371 }
2372
2373 UnicodeString&
unquote(const UnicodeString & pattern,UnicodeString & result)2374 TimeZoneFormat::unquote(const UnicodeString& pattern, UnicodeString& result) {
2375 if (pattern.indexOf(SINGLEQUOTE) < 0) {
2376 result.setTo(pattern);
2377 return result;
2378 }
2379 result.remove();
2380 UBool isPrevQuote = FALSE;
2381 UBool inQuote = FALSE;
2382 for (int32_t i = 0; i < pattern.length(); i++) {
2383 UChar c = pattern.charAt(i);
2384 if (c == SINGLEQUOTE) {
2385 if (isPrevQuote) {
2386 result.append(c);
2387 isPrevQuote = FALSE;
2388 } else {
2389 isPrevQuote = TRUE;
2390 }
2391 inQuote = !inQuote;
2392 } else {
2393 isPrevQuote = FALSE;
2394 result.append(c);
2395 }
2396 }
2397 return result;
2398 }
2399
2400 UVector*
parseOffsetPattern(const UnicodeString & pattern,OffsetFields required,UErrorCode & status)2401 TimeZoneFormat::parseOffsetPattern(const UnicodeString& pattern, OffsetFields required, UErrorCode& status) {
2402 if (U_FAILURE(status)) {
2403 return NULL;
2404 }
2405 UVector* result = new UVector(deleteGMTOffsetField, NULL, status);
2406 if (result == NULL) {
2407 status = U_MEMORY_ALLOCATION_ERROR;
2408 return NULL;
2409 }
2410
2411 int32_t checkBits = 0;
2412 UBool isPrevQuote = FALSE;
2413 UBool inQuote = FALSE;
2414 UChar textBuf[32];
2415 UnicodeString text(textBuf, 0, UPRV_LENGTHOF(textBuf));
2416 GMTOffsetField::FieldType itemType = GMTOffsetField::TEXT;
2417 int32_t itemLength = 1;
2418
2419 for (int32_t i = 0; i < pattern.length(); i++) {
2420 UChar ch = pattern.charAt(i);
2421 if (ch == SINGLEQUOTE) {
2422 if (isPrevQuote) {
2423 text.append(SINGLEQUOTE);
2424 isPrevQuote = FALSE;
2425 } else {
2426 isPrevQuote = TRUE;
2427 if (itemType != GMTOffsetField::TEXT) {
2428 if (GMTOffsetField::isValid(itemType, itemLength)) {
2429 GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, (uint8_t)itemLength, status);
2430 result->addElement(fld, status);
2431 if (U_FAILURE(status)) {
2432 break;
2433 }
2434 } else {
2435 status = U_ILLEGAL_ARGUMENT_ERROR;
2436 break;
2437 }
2438 itemType = GMTOffsetField::TEXT;
2439 }
2440 }
2441 inQuote = !inQuote;
2442 } else {
2443 isPrevQuote = FALSE;
2444 if (inQuote) {
2445 text.append(ch);
2446 } else {
2447 GMTOffsetField::FieldType tmpType = GMTOffsetField::getTypeByLetter(ch);
2448 if (tmpType != GMTOffsetField::TEXT) {
2449 // an offset time pattern character
2450 if (tmpType == itemType) {
2451 itemLength++;
2452 } else {
2453 if (itemType == GMTOffsetField::TEXT) {
2454 if (text.length() > 0) {
2455 GMTOffsetField* textfld = GMTOffsetField::createText(text, status);
2456 result->addElement(textfld, status);
2457 if (U_FAILURE(status)) {
2458 break;
2459 }
2460 text.remove();
2461 }
2462 } else {
2463 if (GMTOffsetField::isValid(itemType, itemLength)) {
2464 GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, itemLength, status);
2465 result->addElement(fld, status);
2466 if (U_FAILURE(status)) {
2467 break;
2468 }
2469 } else {
2470 status = U_ILLEGAL_ARGUMENT_ERROR;
2471 break;
2472 }
2473 }
2474 itemType = tmpType;
2475 itemLength = 1;
2476 checkBits |= tmpType;
2477 }
2478 } else {
2479 // a string literal
2480 if (itemType != GMTOffsetField::TEXT) {
2481 if (GMTOffsetField::isValid(itemType, itemLength)) {
2482 GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, itemLength, status);
2483 result->addElement(fld, status);
2484 if (U_FAILURE(status)) {
2485 break;
2486 }
2487 } else {
2488 status = U_ILLEGAL_ARGUMENT_ERROR;
2489 break;
2490 }
2491 itemType = GMTOffsetField::TEXT;
2492 }
2493 text.append(ch);
2494 }
2495 }
2496 }
2497 }
2498 // handle last item
2499 if (U_SUCCESS(status)) {
2500 if (itemType == GMTOffsetField::TEXT) {
2501 if (text.length() > 0) {
2502 GMTOffsetField* tfld = GMTOffsetField::createText(text, status);
2503 result->addElement(tfld, status);
2504 }
2505 } else {
2506 if (GMTOffsetField::isValid(itemType, itemLength)) {
2507 GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, itemLength, status);
2508 result->addElement(fld, status);
2509 } else {
2510 status = U_ILLEGAL_ARGUMENT_ERROR;
2511 }
2512 }
2513
2514 // Check all required fields are set
2515 if (U_SUCCESS(status)) {
2516 int32_t reqBits = 0;
2517 switch (required) {
2518 case FIELDS_H:
2519 reqBits = GMTOffsetField::HOUR;
2520 break;
2521 case FIELDS_HM:
2522 reqBits = GMTOffsetField::HOUR | GMTOffsetField::MINUTE;
2523 break;
2524 case FIELDS_HMS:
2525 reqBits = GMTOffsetField::HOUR | GMTOffsetField::MINUTE | GMTOffsetField::SECOND;
2526 break;
2527 }
2528 if (checkBits == reqBits) {
2529 // all required fields are set, no extra fields
2530 return result;
2531 }
2532 }
2533 }
2534
2535 // error
2536 delete result;
2537 return NULL;
2538 }
2539
2540 UnicodeString&
expandOffsetPattern(const UnicodeString & offsetHM,UnicodeString & result,UErrorCode & status)2541 TimeZoneFormat::expandOffsetPattern(const UnicodeString& offsetHM, UnicodeString& result, UErrorCode& status) {
2542 result.setToBogus();
2543 if (U_FAILURE(status)) {
2544 return result;
2545 }
2546 U_ASSERT(u_strlen(DEFAULT_GMT_OFFSET_MINUTE_PATTERN) == 2);
2547
2548 int32_t idx_mm = offsetHM.indexOf(DEFAULT_GMT_OFFSET_MINUTE_PATTERN, 2, 0);
2549 if (idx_mm < 0) {
2550 // Bad time zone hour pattern data
2551 status = U_ILLEGAL_ARGUMENT_ERROR;
2552 return result;
2553 }
2554
2555 UnicodeString sep;
2556 int32_t idx_H = offsetHM.tempSubString(0, idx_mm).lastIndexOf((UChar)0x0048 /* H */);
2557 if (idx_H >= 0) {
2558 sep = offsetHM.tempSubString(idx_H + 1, idx_mm - (idx_H + 1));
2559 }
2560 result.setTo(offsetHM.tempSubString(0, idx_mm + 2));
2561 result.append(sep);
2562 result.append(DEFAULT_GMT_OFFSET_SECOND_PATTERN, -1);
2563 result.append(offsetHM.tempSubString(idx_mm + 2));
2564 return result;
2565 }
2566
2567 UnicodeString&
truncateOffsetPattern(const UnicodeString & offsetHM,UnicodeString & result,UErrorCode & status)2568 TimeZoneFormat::truncateOffsetPattern(const UnicodeString& offsetHM, UnicodeString& result, UErrorCode& status) {
2569 result.setToBogus();
2570 if (U_FAILURE(status)) {
2571 return result;
2572 }
2573 U_ASSERT(u_strlen(DEFAULT_GMT_OFFSET_MINUTE_PATTERN) == 2);
2574
2575 int32_t idx_mm = offsetHM.indexOf(DEFAULT_GMT_OFFSET_MINUTE_PATTERN, 2, 0);
2576 if (idx_mm < 0) {
2577 // Bad time zone hour pattern data
2578 status = U_ILLEGAL_ARGUMENT_ERROR;
2579 return result;
2580 }
2581 UChar HH[] = {0x0048, 0x0048};
2582 int32_t idx_HH = offsetHM.tempSubString(0, idx_mm).lastIndexOf(HH, 2, 0);
2583 if (idx_HH >= 0) {
2584 return result.setTo(offsetHM.tempSubString(0, idx_HH + 2));
2585 }
2586 int32_t idx_H = offsetHM.tempSubString(0, idx_mm).lastIndexOf((UChar)0x0048, 0);
2587 if (idx_H >= 0) {
2588 return result.setTo(offsetHM.tempSubString(0, idx_H + 1));
2589 }
2590 // Bad time zone hour pattern data
2591 status = U_ILLEGAL_ARGUMENT_ERROR;
2592 return result;
2593 }
2594
2595 void
initGMTOffsetPatterns(UErrorCode & status)2596 TimeZoneFormat::initGMTOffsetPatterns(UErrorCode& status) {
2597 for (int32_t type = 0; type < UTZFMT_PAT_COUNT; type++) {
2598 switch (type) {
2599 case UTZFMT_PAT_POSITIVE_H:
2600 case UTZFMT_PAT_NEGATIVE_H:
2601 fGMTOffsetPatternItems[type] = parseOffsetPattern(fGMTOffsetPatterns[type], FIELDS_H, status);
2602 break;
2603 case UTZFMT_PAT_POSITIVE_HM:
2604 case UTZFMT_PAT_NEGATIVE_HM:
2605 fGMTOffsetPatternItems[type] = parseOffsetPattern(fGMTOffsetPatterns[type], FIELDS_HM, status);
2606 break;
2607 case UTZFMT_PAT_POSITIVE_HMS:
2608 case UTZFMT_PAT_NEGATIVE_HMS:
2609 fGMTOffsetPatternItems[type] = parseOffsetPattern(fGMTOffsetPatterns[type], FIELDS_HMS, status);
2610 break;
2611 }
2612 }
2613 checkAbuttingHoursAndMinutes();
2614 }
2615
2616 void
checkAbuttingHoursAndMinutes()2617 TimeZoneFormat::checkAbuttingHoursAndMinutes() {
2618 fAbuttingOffsetHoursAndMinutes= FALSE;
2619 for (int32_t type = 0; type < UTZFMT_PAT_COUNT; type++) {
2620 UBool afterH = FALSE;
2621 UVector *items = fGMTOffsetPatternItems[type];
2622 for (int32_t i = 0; i < items->size(); i++) {
2623 const GMTOffsetField* item = (GMTOffsetField*)items->elementAt(i);
2624 GMTOffsetField::FieldType type = item->getType();
2625 if (type != GMTOffsetField::TEXT) {
2626 if (afterH) {
2627 fAbuttingOffsetHoursAndMinutes = TRUE;
2628 break;
2629 } else if (type == GMTOffsetField::HOUR) {
2630 afterH = TRUE;
2631 }
2632 } else if (afterH) {
2633 break;
2634 }
2635 }
2636 if (fAbuttingOffsetHoursAndMinutes) {
2637 break;
2638 }
2639 }
2640 }
2641
2642 UBool
toCodePoints(const UnicodeString & str,UChar32 * codeArray,int32_t size)2643 TimeZoneFormat::toCodePoints(const UnicodeString& str, UChar32* codeArray, int32_t size) {
2644 int32_t count = str.countChar32();
2645 if (count != size) {
2646 return FALSE;
2647 }
2648
2649 for (int32_t idx = 0, start = 0; idx < size; idx++) {
2650 codeArray[idx] = str.char32At(start);
2651 start = str.moveIndex32(start, 1);
2652 }
2653
2654 return TRUE;
2655 }
2656
2657 TimeZone*
createTimeZoneForOffset(int32_t offset) const2658 TimeZoneFormat::createTimeZoneForOffset(int32_t offset) const {
2659 if (offset == 0) {
2660 // when offset is 0, we should use "Etc/GMT"
2661 return TimeZone::createTimeZone(UnicodeString(TRUE, TZID_GMT, -1));
2662 }
2663 return ZoneMeta::createCustomTimeZone(offset);
2664 }
2665
2666 UTimeZoneFormatTimeType
getTimeType(UTimeZoneNameType nameType)2667 TimeZoneFormat::getTimeType(UTimeZoneNameType nameType) {
2668 switch (nameType) {
2669 case UTZNM_LONG_STANDARD:
2670 case UTZNM_SHORT_STANDARD:
2671 return UTZFMT_TIME_TYPE_STANDARD;
2672
2673 case UTZNM_LONG_DAYLIGHT:
2674 case UTZNM_SHORT_DAYLIGHT:
2675 return UTZFMT_TIME_TYPE_DAYLIGHT;
2676
2677 default:
2678 return UTZFMT_TIME_TYPE_UNKNOWN;
2679 }
2680 }
2681
2682 UnicodeString&
getTimeZoneID(const TimeZoneNames::MatchInfoCollection * matches,int32_t idx,UnicodeString & tzID) const2683 TimeZoneFormat::getTimeZoneID(const TimeZoneNames::MatchInfoCollection* matches, int32_t idx, UnicodeString& tzID) const {
2684 if (!matches->getTimeZoneIDAt(idx, tzID)) {
2685 UChar mzIDBuf[32];
2686 UnicodeString mzID(mzIDBuf, 0, UPRV_LENGTHOF(mzIDBuf));
2687 if (matches->getMetaZoneIDAt(idx, mzID)) {
2688 fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, tzID);
2689 }
2690 }
2691 return tzID;
2692 }
2693
2694
2695 class ZoneIdMatchHandler : public TextTrieMapSearchResultHandler {
2696 public:
2697 ZoneIdMatchHandler();
2698 virtual ~ZoneIdMatchHandler();
2699
2700 UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status);
2701 const UChar* getID();
2702 int32_t getMatchLen();
2703 private:
2704 int32_t fLen;
2705 const UChar* fID;
2706 };
2707
ZoneIdMatchHandler()2708 ZoneIdMatchHandler::ZoneIdMatchHandler()
2709 : fLen(0), fID(NULL) {
2710 }
2711
~ZoneIdMatchHandler()2712 ZoneIdMatchHandler::~ZoneIdMatchHandler() {
2713 }
2714
2715 UBool
handleMatch(int32_t matchLength,const CharacterNode * node,UErrorCode & status)2716 ZoneIdMatchHandler::handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status) {
2717 if (U_FAILURE(status)) {
2718 return FALSE;
2719 }
2720 if (node->hasValues()) {
2721 const UChar* id = (const UChar*)node->getValue(0);
2722 if (id != NULL) {
2723 if (fLen < matchLength) {
2724 fID = id;
2725 fLen = matchLength;
2726 }
2727 }
2728 }
2729 return TRUE;
2730 }
2731
2732 const UChar*
getID()2733 ZoneIdMatchHandler::getID() {
2734 return fID;
2735 }
2736
2737 int32_t
getMatchLen()2738 ZoneIdMatchHandler::getMatchLen() {
2739 return fLen;
2740 }
2741
2742
initZoneIdTrie(UErrorCode & status)2743 static void U_CALLCONV initZoneIdTrie(UErrorCode &status) {
2744 U_ASSERT(gZoneIdTrie == NULL);
2745 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONEFORMAT, tzfmt_cleanup);
2746 gZoneIdTrie = new TextTrieMap(TRUE, NULL); // No deleter, because values are pooled by ZoneMeta
2747 if (gZoneIdTrie == NULL) {
2748 status = U_MEMORY_ALLOCATION_ERROR;
2749 return;
2750 }
2751 StringEnumeration *tzenum = TimeZone::createEnumeration();
2752 const UnicodeString *id;
2753 while ((id = tzenum->snext(status))) {
2754 const UChar* uid = ZoneMeta::findTimeZoneID(*id);
2755 if (uid) {
2756 gZoneIdTrie->put(uid, const_cast<UChar *>(uid), status);
2757 }
2758 }
2759 delete tzenum;
2760 }
2761
2762
2763 UnicodeString&
parseZoneID(const UnicodeString & text,ParsePosition & pos,UnicodeString & tzID) const2764 TimeZoneFormat::parseZoneID(const UnicodeString& text, ParsePosition& pos, UnicodeString& tzID) const {
2765 UErrorCode status = U_ZERO_ERROR;
2766 umtx_initOnce(gZoneIdTrieInitOnce, &initZoneIdTrie, status);
2767
2768 int32_t start = pos.getIndex();
2769 int32_t len = 0;
2770 tzID.setToBogus();
2771
2772 if (U_SUCCESS(status)) {
2773 LocalPointer<ZoneIdMatchHandler> handler(new ZoneIdMatchHandler());
2774 gZoneIdTrie->search(text, start, handler.getAlias(), status);
2775 len = handler->getMatchLen();
2776 if (len > 0) {
2777 tzID.setTo(handler->getID(), -1);
2778 }
2779 }
2780
2781 if (len > 0) {
2782 pos.setIndex(start + len);
2783 } else {
2784 pos.setErrorIndex(start);
2785 }
2786
2787 return tzID;
2788 }
2789
initShortZoneIdTrie(UErrorCode & status)2790 static void U_CALLCONV initShortZoneIdTrie(UErrorCode &status) {
2791 U_ASSERT(gShortZoneIdTrie == NULL);
2792 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONEFORMAT, tzfmt_cleanup);
2793 StringEnumeration *tzenum = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL, NULL, NULL, status);
2794 if (U_SUCCESS(status)) {
2795 gShortZoneIdTrie = new TextTrieMap(TRUE, NULL); // No deleter, because values are pooled by ZoneMeta
2796 if (gShortZoneIdTrie == NULL) {
2797 status = U_MEMORY_ALLOCATION_ERROR;
2798 } else {
2799 const UnicodeString *id;
2800 while ((id = tzenum->snext(status))) {
2801 const UChar* uID = ZoneMeta::findTimeZoneID(*id);
2802 const UChar* shortID = ZoneMeta::getShortID(*id);
2803 if (shortID && uID) {
2804 gShortZoneIdTrie->put(shortID, const_cast<UChar *>(uID), status);
2805 }
2806 }
2807 }
2808 }
2809 delete tzenum;
2810 }
2811
2812
2813 UnicodeString&
parseShortZoneID(const UnicodeString & text,ParsePosition & pos,UnicodeString & tzID) const2814 TimeZoneFormat::parseShortZoneID(const UnicodeString& text, ParsePosition& pos, UnicodeString& tzID) const {
2815 UErrorCode status = U_ZERO_ERROR;
2816 umtx_initOnce(gShortZoneIdTrieInitOnce, &initShortZoneIdTrie, status);
2817
2818 int32_t start = pos.getIndex();
2819 int32_t len = 0;
2820 tzID.setToBogus();
2821
2822 if (U_SUCCESS(status)) {
2823 LocalPointer<ZoneIdMatchHandler> handler(new ZoneIdMatchHandler());
2824 gShortZoneIdTrie->search(text, start, handler.getAlias(), status);
2825 len = handler->getMatchLen();
2826 if (len > 0) {
2827 tzID.setTo(handler->getID(), -1);
2828 }
2829 }
2830
2831 if (len > 0) {
2832 pos.setIndex(start + len);
2833 } else {
2834 pos.setErrorIndex(start);
2835 }
2836
2837 return tzID;
2838 }
2839
2840
2841 UnicodeString&
parseExemplarLocation(const UnicodeString & text,ParsePosition & pos,UnicodeString & tzID) const2842 TimeZoneFormat::parseExemplarLocation(const UnicodeString& text, ParsePosition& pos, UnicodeString& tzID) const {
2843 int32_t startIdx = pos.getIndex();
2844 int32_t parsedPos = -1;
2845 tzID.setToBogus();
2846
2847 UErrorCode status = U_ZERO_ERROR;
2848 LocalPointer<TimeZoneNames::MatchInfoCollection> exemplarMatches(fTimeZoneNames->find(text, startIdx, UTZNM_EXEMPLAR_LOCATION, status));
2849 if (U_FAILURE(status)) {
2850 pos.setErrorIndex(startIdx);
2851 return tzID;
2852 }
2853 int32_t matchIdx = -1;
2854 if (!exemplarMatches.isNull()) {
2855 for (int32_t i = 0; i < exemplarMatches->size(); i++) {
2856 if (startIdx + exemplarMatches->getMatchLengthAt(i) > parsedPos) {
2857 matchIdx = i;
2858 parsedPos = startIdx + exemplarMatches->getMatchLengthAt(i);
2859 }
2860 }
2861 if (parsedPos > 0) {
2862 pos.setIndex(parsedPos);
2863 getTimeZoneID(exemplarMatches.getAlias(), matchIdx, tzID);
2864 }
2865 }
2866
2867 if (tzID.length() == 0) {
2868 pos.setErrorIndex(startIdx);
2869 }
2870
2871 return tzID;
2872 }
2873
2874 U_NAMESPACE_END
2875
2876 #endif
2877