The Tor Browser / file comparison

comparison: intl/icu/source/i18n/zonemeta.cpp

intl/icu/source/i18n/zonemeta.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:6d1cdc21a6bf
1 /*
2 *******************************************************************************
3 * Copyright (C) 2007-2013, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 *******************************************************************************
6 */
7
8 #include "unicode/utypes.h"
9
10 #if !UCONFIG_NO_FORMATTING
11
12 #include "zonemeta.h"
13
14 #include "unicode/timezone.h"
15 #include "unicode/ustring.h"
16 #include "unicode/putil.h"
17 #include "unicode/simpletz.h"
18
19 #include "umutex.h"
20 #include "uvector.h"
21 #include "cmemory.h"
22 #include "gregoimp.h"
23 #include "cstring.h"
24 #include "ucln_in.h"
25 #include "uassert.h"
26 #include "uresimp.h"
27 #include "uhash.h"
28 #include "olsontz.h"
29
30 static UMutex gZoneMetaLock = U_MUTEX_INITIALIZER;
31
32 // CLDR Canonical ID mapping table
33 static UHashtable *gCanonicalIDCache = NULL;
34 static icu::UInitOnce gCanonicalIDCacheInitOnce = U_INITONCE_INITIALIZER;
35
36 // Metazone mapping table
37 static UHashtable *gOlsonToMeta = NULL;
38 static icu::UInitOnce gOlsonToMetaInitOnce = U_INITONCE_INITIALIZER;
39
40 // Available metazone IDs vector and table
41 static icu::UVector *gMetaZoneIDs = NULL;
42 static UHashtable *gMetaZoneIDTable = NULL;
43 static icu::UInitOnce gMetaZoneIDsInitOnce = U_INITONCE_INITIALIZER;
44
45 // Country info vectors
46 static icu::UVector *gSingleZoneCountries = NULL;
47 static icu::UVector *gMultiZonesCountries = NULL;
48 static icu::UInitOnce gCountryInfoVectorsInitOnce = U_INITONCE_INITIALIZER;
49
50 U_CDECL_BEGIN
51
52 /**
53 * Cleanup callback func
54 */
55 static UBool U_CALLCONV zoneMeta_cleanup(void)
56 {
57 if (gCanonicalIDCache != NULL) {
58 uhash_close(gCanonicalIDCache);
59 gCanonicalIDCache = NULL;
60 }
61 gCanonicalIDCacheInitOnce.reset();
62
63 if (gOlsonToMeta != NULL) {
64 uhash_close(gOlsonToMeta);
65 gOlsonToMeta = NULL;
66 }
67 gOlsonToMetaInitOnce.reset();
68
69 if (gMetaZoneIDTable != NULL) {
70 uhash_close(gMetaZoneIDTable);
71 gMetaZoneIDTable = NULL;
72 }
73 // delete after closing gMetaZoneIDTable, because it holds
74 // value objects held by the hashtable
75 delete gMetaZoneIDs;
76 gMetaZoneIDs = NULL;
77 gMetaZoneIDsInitOnce.reset();
78
79 delete gSingleZoneCountries;
80 gSingleZoneCountries = NULL;
81 delete gMultiZonesCountries;
82 gMultiZonesCountries = NULL;
83 gCountryInfoVectorsInitOnce.reset();
84
85 return TRUE;
86 }
87
88 /**
89 * Deleter for UChar* string
90 */
91 static void U_CALLCONV
92 deleteUCharString(void *obj) {
93 UChar *entry = (UChar*)obj;
94 uprv_free(entry);
95 }
96
97 /**
98 * Deleter for UVector
99 */
100 static void U_CALLCONV
101 deleteUVector(void *obj) {
102 delete (icu::UVector*) obj;
103 }
104
105 /**
106 * Deleter for OlsonToMetaMappingEntry
107 */
108 static void U_CALLCONV
109 deleteOlsonToMetaMappingEntry(void *obj) {
110 icu::OlsonToMetaMappingEntry *entry = (icu::OlsonToMetaMappingEntry*)obj;
111 uprv_free(entry);
112 }
113
114 U_CDECL_END
115
116 U_NAMESPACE_BEGIN
117
118 #define ZID_KEY_MAX 128
119
120 static const char gMetaZones[] = "metaZones";
121 static const char gMetazoneInfo[] = "metazoneInfo";
122 static const char gMapTimezonesTag[] = "mapTimezones";
123
124 static const char gKeyTypeData[] = "keyTypeData";
125 static const char gTypeAliasTag[] = "typeAlias";
126 static const char gTypeMapTag[] = "typeMap";
127 static const char gTimezoneTag[] = "timezone";
128
129 static const char gPrimaryZonesTag[] = "primaryZones";
130
131 static const char gWorldTag[] = "001";
132
133 static const UChar gWorld[] = {0x30, 0x30, 0x31, 0x00}; // "001"
134
135 static const UChar gDefaultFrom[] = {0x31, 0x39, 0x37, 0x30, 0x2D, 0x30, 0x31, 0x2D, 0x30, 0x31,
136 0x20, 0x30, 0x30, 0x3A, 0x30, 0x30, 0x00}; // "1970-01-01 00:00"
137 static const UChar gDefaultTo[] = {0x39, 0x39, 0x39, 0x39, 0x2D, 0x31, 0x32, 0x2D, 0x33, 0x31,
138 0x20, 0x32, 0x33, 0x3A, 0x35, 0x39, 0x00}; // "9999-12-31 23:59"
139
140 static const UChar gCustomTzPrefix[] = {0x47, 0x4D, 0x54, 0}; // "GMT"
141
142 #define ASCII_DIGIT(c) (((c)>=0x30 && (c)<=0x39) ? (c)-0x30 : -1)
143
144 /*
145 * Convert a date string used by metazone mappings to UDate.
146 * The format used by CLDR metazone mapping is "yyyy-MM-dd HH:mm".
147 */
148 static UDate
149 parseDate (const UChar *text, UErrorCode &status) {
150 if (U_FAILURE(status)) {
151 return 0;
152 }
153 int32_t len = u_strlen(text);
154 if (len != 16 && len != 10) {
155 // It must be yyyy-MM-dd HH:mm (length 16) or yyyy-MM-dd (length 10)
156 status = U_INVALID_FORMAT_ERROR;
157 return 0;
158 }
159
160 int32_t year = 0, month = 0, day = 0, hour = 0, min = 0, n;
161 int32_t idx;
162
163 // "yyyy" (0 - 3)
164 for (idx = 0; idx <= 3 && U_SUCCESS(status); idx++) {
165 n = ASCII_DIGIT((int32_t)text[idx]);
166 if (n >= 0) {
167 year = 10*year + n;
168 } else {
169 status = U_INVALID_FORMAT_ERROR;
170 }
171 }
172 // "MM" (5 - 6)
173 for (idx = 5; idx <= 6 && U_SUCCESS(status); idx++) {
174 n = ASCII_DIGIT((int32_t)text[idx]);
175 if (n >= 0) {
176 month = 10*month + n;
177 } else {
178 status = U_INVALID_FORMAT_ERROR;
179 }
180 }
181 // "dd" (8 - 9)
182 for (idx = 8; idx <= 9 && U_SUCCESS(status); idx++) {
183 n = ASCII_DIGIT((int32_t)text[idx]);
184 if (n >= 0) {
185 day = 10*day + n;
186 } else {
187 status = U_INVALID_FORMAT_ERROR;
188 }
189 }
190 if (len == 16) {
191 // "HH" (11 - 12)
192 for (idx = 11; idx <= 12 && U_SUCCESS(status); idx++) {
193 n = ASCII_DIGIT((int32_t)text[idx]);
194 if (n >= 0) {
195 hour = 10*hour + n;
196 } else {
197 status = U_INVALID_FORMAT_ERROR;
198 }
199 }
200 // "mm" (14 - 15)
201 for (idx = 14; idx <= 15 && U_SUCCESS(status); idx++) {
202 n = ASCII_DIGIT((int32_t)text[idx]);
203 if (n >= 0) {
204 min = 10*min + n;
205 } else {
206 status = U_INVALID_FORMAT_ERROR;
207 }
208 }
209 }
210
211 if (U_SUCCESS(status)) {
212 UDate date = Grego::fieldsToDay(year, month - 1, day) * U_MILLIS_PER_DAY
213 + hour * U_MILLIS_PER_HOUR + min * U_MILLIS_PER_MINUTE;
214 return date;
215 }
216 return 0;
217 }
218
219 static void U_CALLCONV initCanonicalIDCache(UErrorCode &status) {
220 gCanonicalIDCache = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status);
221 if (gCanonicalIDCache == NULL) {
222 status = U_MEMORY_ALLOCATION_ERROR;
223 }
224 if (U_FAILURE(status)) {
225 gCanonicalIDCache = NULL;
226 }
227 // No key/value deleters - keys/values are from a resource bundle
228 ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);
229 }
230
231
232 const UChar* U_EXPORT2
233 ZoneMeta::getCanonicalCLDRID(const UnicodeString &tzid, UErrorCode& status) {
234 if (U_FAILURE(status)) {
235 return NULL;
236 }
237
238 int32_t len = tzid.length();
239 if (len > ZID_KEY_MAX) {
240 status = U_ILLEGAL_ARGUMENT_ERROR;
241 return NULL;
242 }
243
244 // Checking the cached results
245 umtx_initOnce(gCanonicalIDCacheInitOnce, &initCanonicalIDCache, status);
246 if (U_FAILURE(status)) {
247 return NULL;
248 }
249
250 const UChar *canonicalID = NULL;
251
252 UErrorCode tmpStatus = U_ZERO_ERROR;
253 UChar utzid[ZID_KEY_MAX + 1];
254 tzid.extract(utzid, ZID_KEY_MAX + 1, tmpStatus);
255 U_ASSERT(tmpStatus == U_ZERO_ERROR); // we checked the length of tzid already
256
257 // Check if it was already cached
258 umtx_lock(&gZoneMetaLock);
259 {
260 canonicalID = (const UChar *)uhash_get(gCanonicalIDCache, utzid);
261 }
262 umtx_unlock(&gZoneMetaLock);
263
264 if (canonicalID != NULL) {
265 return canonicalID;
266 }
267
268 // If not, resolve CLDR canonical ID with resource data
269 UBool isInputCanonical = FALSE;
270 char id[ZID_KEY_MAX + 1];
271 const UChar* idChars = tzid.getBuffer();
272
273 u_UCharsToChars(idChars,id,len);
274 id[len] = (char) 0; // Make sure it is null terminated.
275
276 // replace '/' with ':'
277 char *p = id;
278 while (*p++) {
279 if (*p == '/') {
280 *p = ':';
281 }
282 }
283
284 UResourceBundle *top = ures_openDirect(NULL, gKeyTypeData, &tmpStatus);
285 UResourceBundle *rb = ures_getByKey(top, gTypeMapTag, NULL, &tmpStatus);
286 ures_getByKey(rb, gTimezoneTag, rb, &tmpStatus);
287 ures_getByKey(rb, id, rb, &tmpStatus);
288 if (U_SUCCESS(tmpStatus)) {
289 // type entry (canonical) found
290 // the input is the canonical ID. resolve to const UChar*
291 canonicalID = TimeZone::findID(tzid);
292 isInputCanonical = TRUE;
293 }
294
295 if (canonicalID == NULL) {
296 // If a map element not found, then look for an alias
297 tmpStatus = U_ZERO_ERROR;
298 ures_getByKey(top, gTypeAliasTag, rb, &tmpStatus);
299 ures_getByKey(rb, gTimezoneTag, rb, &tmpStatus);
300 const UChar *canonical = ures_getStringByKey(rb,id,NULL,&tmpStatus);
301 if (U_SUCCESS(tmpStatus)) {
302 // canonical map found
303 canonicalID = canonical;
304 }
305
306 if (canonicalID == NULL) {
307 // Dereference the input ID using the tz data
308 const UChar *derefer = TimeZone::dereferOlsonLink(tzid);
309 if (derefer == NULL) {
310 status = U_ILLEGAL_ARGUMENT_ERROR;
311 } else {
312 len = u_strlen(derefer);
313 u_UCharsToChars(derefer,id,len);
314 id[len] = (char) 0; // Make sure it is null terminated.
315
316 // replace '/' with ':'
317 char *p = id;
318 while (*p++) {
319 if (*p == '/') {
320 *p = ':';
321 }
322 }
323
324 // If a dereference turned something up then look for an alias.
325 // rb still points to the alias table, so we don't have to go looking
326 // for it.
327 tmpStatus = U_ZERO_ERROR;
328 canonical = ures_getStringByKey(rb,id,NULL,&tmpStatus);
329 if (U_SUCCESS(tmpStatus)) {
330 // canonical map for the dereferenced ID found
331 canonicalID = canonical;
332 } else {
333 canonicalID = derefer;
334 isInputCanonical = TRUE;
335 }
336 }
337 }
338 }
339 ures_close(rb);
340 ures_close(top);
341
342 if (U_SUCCESS(status)) {
343 U_ASSERT(canonicalID != NULL); // canocanilD must be non-NULL here
344
345 // Put the resolved canonical ID to the cache
346 umtx_lock(&gZoneMetaLock);
347 {
348 const UChar* idInCache = (const UChar *)uhash_get(gCanonicalIDCache, utzid);
349 if (idInCache == NULL) {
350 const UChar* key = ZoneMeta::findTimeZoneID(tzid);
351 U_ASSERT(key != NULL);
352 if (key != NULL) {
353 idInCache = (const UChar *)uhash_put(gCanonicalIDCache, (void *)key, (void *)canonicalID, &status);
354 U_ASSERT(idInCache == NULL);
355 }
356 }
357 if (U_SUCCESS(status) && isInputCanonical) {
358 // Also put canonical ID itself into the cache if not exist
359 const UChar *canonicalInCache = (const UChar*)uhash_get(gCanonicalIDCache, canonicalID);
360 if (canonicalInCache == NULL) {
361 canonicalInCache = (const UChar *)uhash_put(gCanonicalIDCache, (void *)canonicalID, (void *)canonicalID, &status);
362 U_ASSERT(canonicalInCache == NULL);
363 }
364 }
365 }
366 umtx_unlock(&gZoneMetaLock);
367 }
368
369 return canonicalID;
370 }
371
372 UnicodeString& U_EXPORT2
373 ZoneMeta::getCanonicalCLDRID(const UnicodeString &tzid, UnicodeString &systemID, UErrorCode& status) {
374 const UChar *canonicalID = getCanonicalCLDRID(tzid, status);
375 if (U_FAILURE(status) || canonicalID == NULL) {
376 systemID.setToBogus();
377 return systemID;
378 }
379 systemID.setTo(TRUE, canonicalID, -1);
380 return systemID;
381 }
382
383 const UChar* U_EXPORT2
384 ZoneMeta::getCanonicalCLDRID(const TimeZone& tz) {
385 if (dynamic_cast<const OlsonTimeZone *>(&tz) != NULL) {
386 // short cut for OlsonTimeZone
387 const OlsonTimeZone *otz = (const OlsonTimeZone*)&tz;
388 return otz->getCanonicalID();
389 }
390 UErrorCode status = U_ZERO_ERROR;
391 UnicodeString tzID;
392 return getCanonicalCLDRID(tz.getID(tzID), status);
393 }
394
395 static void U_CALLCONV countryInfoVectorsInit(UErrorCode &status) {
396 // Create empty vectors
397 // No deleters for these UVectors, it's a reference to a resource bundle string.
398 gSingleZoneCountries = new UVector(NULL, uhash_compareUChars, status);
399 if (gSingleZoneCountries == NULL) {
400 status = U_MEMORY_ALLOCATION_ERROR;
401 }
402 gMultiZonesCountries = new UVector(NULL, uhash_compareUChars, status);
403 if (gMultiZonesCountries == NULL) {
404 status = U_MEMORY_ALLOCATION_ERROR;
405 }
406
407 if (U_FAILURE(status)) {
408 delete gSingleZoneCountries;
409 delete gMultiZonesCountries;
410 gSingleZoneCountries = NULL;
411 gMultiZonesCountries = NULL;
412 }
413 ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);
414 }
415
416
417 UnicodeString& U_EXPORT2
418 ZoneMeta::getCanonicalCountry(const UnicodeString &tzid, UnicodeString &country, UBool *isPrimary /* = NULL */) {
419 if (isPrimary != NULL) {
420 *isPrimary = FALSE;
421 }
422
423 const UChar *region = TimeZone::getRegion(tzid);
424 if (region != NULL && u_strcmp(gWorld, region) != 0) {
425 country.setTo(region, -1);
426 } else {
427 country.setToBogus();
428 return country;
429 }
430
431 if (isPrimary != NULL) {
432 char regionBuf[] = {0, 0, 0};
433
434 // Checking the cached results
435 UErrorCode status = U_ZERO_ERROR;
436 umtx_initOnce(gCountryInfoVectorsInitOnce, &countryInfoVectorsInit, status);
437 if (U_FAILURE(status)) {
438 return country;
439 }
440
441 // Check if it was already cached
442 UBool cached = FALSE;
443 UBool singleZone = FALSE;
444 umtx_lock(&gZoneMetaLock);
445 {
446 singleZone = cached = gSingleZoneCountries->contains((void*)region);
447 if (!cached) {
448 cached = gMultiZonesCountries->contains((void*)region);
449 }
450 }
451 umtx_unlock(&gZoneMetaLock);
452
453 if (!cached) {
454 // We need to go through all zones associated with the region.
455 // This is relatively heavy operation.
456
457 U_ASSERT(u_strlen(region) == 2);
458
459 u_UCharsToChars(region, regionBuf, 2);
460
461 StringEnumeration *ids = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL_LOCATION, regionBuf, NULL, status);
462 int32_t idsLen = ids->count(status);
463 if (U_SUCCESS(status) && idsLen == 1) {
464 // only the single zone is available for the region
465 singleZone = TRUE;
466 }
467 delete ids;
468
469 // Cache the result
470 umtx_lock(&gZoneMetaLock);
471 {
472 UErrorCode ec = U_ZERO_ERROR;
473 if (singleZone) {
474 if (!gSingleZoneCountries->contains((void*)region)) {
475 gSingleZoneCountries->addElement((void*)region, ec);
476 }
477 } else {
478 if (!gMultiZonesCountries->contains((void*)region)) {
479 gMultiZonesCountries->addElement((void*)region, ec);
480 }
481 }
482 }
483 umtx_unlock(&gZoneMetaLock);
484 }
485
486 if (singleZone) {
487 *isPrimary = TRUE;
488 } else {
489 // Note: We may cache the primary zone map in future.
490
491 // Even a country has multiple zones, one of them might be
492 // dominant and treated as a primary zone
493 int32_t idLen = 0;
494 if (regionBuf[0] == 0) {
495 u_UCharsToChars(region, regionBuf, 2);
496 }
497
498 UResourceBundle *rb = ures_openDirect(NULL, gMetaZones, &status);
499 ures_getByKey(rb, gPrimaryZonesTag, rb, &status);
500 const UChar *primaryZone = ures_getStringByKey(rb, regionBuf, &idLen, &status);
501 if (U_SUCCESS(status)) {
502 if (tzid.compare(primaryZone, idLen) == 0) {
503 *isPrimary = TRUE;
504 } else {
505 // The given ID might not be a canonical ID
506 UnicodeString canonicalID;
507 TimeZone::getCanonicalID(tzid, canonicalID, status);
508 if (U_SUCCESS(status) && canonicalID.compare(primaryZone, idLen) == 0) {
509 *isPrimary = TRUE;
510 }
511 }
512 }
513 ures_close(rb);
514 }
515 }
516
517 return country;
518 }
519
520 UnicodeString& U_EXPORT2
521 ZoneMeta::getMetazoneID(const UnicodeString &tzid, UDate date, UnicodeString &result) {
522 UBool isSet = FALSE;
523 const UVector *mappings = getMetazoneMappings(tzid);
524 if (mappings != NULL) {
525 for (int32_t i = 0; i < mappings->size(); i++) {
526 OlsonToMetaMappingEntry *mzm = (OlsonToMetaMappingEntry*)mappings->elementAt(i);
527 if (mzm->from <= date && mzm->to > date) {
528 result.setTo(mzm->mzid, -1);
529 isSet = TRUE;
530 break;
531 }
532 }
533 }
534 if (!isSet) {
535 result.setToBogus();
536 }
537 return result;
538 }
539
540 static void U_CALLCONV olsonToMetaInit(UErrorCode &status) {
541 U_ASSERT(gOlsonToMeta == NULL);
542 ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);
543 gOlsonToMeta = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status);
544 if (U_FAILURE(status)) {
545 gOlsonToMeta = NULL;
546 } else {
547 uhash_setKeyDeleter(gOlsonToMeta, deleteUCharString);
548 uhash_setValueDeleter(gOlsonToMeta, deleteUVector);
549 }
550 }
551
552
553 const UVector* U_EXPORT2
554 ZoneMeta::getMetazoneMappings(const UnicodeString &tzid) {
555 UErrorCode status = U_ZERO_ERROR;
556 UChar tzidUChars[ZID_KEY_MAX + 1];
557 tzid.extract(tzidUChars, ZID_KEY_MAX + 1, status);
558 if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING) {
559 return NULL;
560 }
561
562 umtx_initOnce(gOlsonToMetaInitOnce, &olsonToMetaInit, status);
563 if (U_FAILURE(status)) {
564 return NULL;
565 }
566
567 // get the mapping from cache
568 const UVector *result = NULL;
569
570 umtx_lock(&gZoneMetaLock);
571 {
572 result = (UVector*) uhash_get(gOlsonToMeta, tzidUChars);
573 }
574 umtx_unlock(&gZoneMetaLock);
575
576 if (result != NULL) {
577 return result;
578 }
579
580 // miss the cache - create new one
581 UVector *tmpResult = createMetazoneMappings(tzid);
582 if (tmpResult == NULL) {
583 // not available
584 return NULL;
585 }
586
587 // put the new one into the cache
588 umtx_lock(&gZoneMetaLock);
589 {
590 // make sure it's already created
591 result = (UVector*) uhash_get(gOlsonToMeta, tzidUChars);
592 if (result == NULL) {
593 // add the one just created
594 int32_t tzidLen = tzid.length() + 1;
595 UChar *key = (UChar*)uprv_malloc(tzidLen * sizeof(UChar));
596 if (key == NULL) {
597 // memory allocation error.. just return NULL
598 result = NULL;
599 delete tmpResult;
600 } else {
601 tzid.extract(key, tzidLen, status);
602 uhash_put(gOlsonToMeta, key, tmpResult, &status);
603 if (U_FAILURE(status)) {
604 // delete the mapping
605 result = NULL;
606 delete tmpResult;
607 } else {
608 result = tmpResult;
609 }
610 }
611 } else {
612 // another thread already put the one
613 delete tmpResult;
614 }
615 }
616 umtx_unlock(&gZoneMetaLock);
617
618 return result;
619 }
620
621 UVector*
622 ZoneMeta::createMetazoneMappings(const UnicodeString &tzid) {
623 UVector *mzMappings = NULL;
624 UErrorCode status = U_ZERO_ERROR;
625
626 UnicodeString canonicalID;
627 UResourceBundle *rb = ures_openDirect(NULL, gMetaZones, &status);
628 ures_getByKey(rb, gMetazoneInfo, rb, &status);
629 getCanonicalCLDRID(tzid, canonicalID, status);
630
631 if (U_SUCCESS(status)) {
632 char tzKey[ZID_KEY_MAX + 1];
633 int32_t tzKeyLen = canonicalID.extract(0, canonicalID.length(), tzKey, sizeof(tzKey), US_INV);
634 tzKey[tzKeyLen] = 0;
635
636 // tzid keys are using ':' as separators
637 char *p = tzKey;
638 while (*p) {
639 if (*p == '/') {
640 *p = ':';
641 }
642 p++;
643 }
644
645 ures_getByKey(rb, tzKey, rb, &status);
646
647 if (U_SUCCESS(status)) {
648 UResourceBundle *mz = NULL;
649 while (ures_hasNext(rb)) {
650 mz = ures_getNextResource(rb, mz, &status);
651
652 const UChar *mz_name = ures_getStringByIndex(mz, 0, NULL, &status);
653 const UChar *mz_from = gDefaultFrom;
654 const UChar *mz_to = gDefaultTo;
655
656 if (ures_getSize(mz) == 3) {
657 mz_from = ures_getStringByIndex(mz, 1, NULL, &status);
658 mz_to = ures_getStringByIndex(mz, 2, NULL, &status);
659 }
660
661 if(U_FAILURE(status)){
662 status = U_ZERO_ERROR;
663 continue;
664 }
665 // We do not want to use SimpleDateformat to parse boundary dates,
666 // because this code could be triggered by the initialization code
667 // used by SimpleDateFormat.
668 UDate from = parseDate(mz_from, status);
669 UDate to = parseDate(mz_to, status);
670 if (U_FAILURE(status)) {
671 status = U_ZERO_ERROR;
672 continue;
673 }
674
675 OlsonToMetaMappingEntry *entry = (OlsonToMetaMappingEntry*)uprv_malloc(sizeof(OlsonToMetaMappingEntry));
676 if (entry == NULL) {
677 status = U_MEMORY_ALLOCATION_ERROR;
678 break;
679 }
680 entry->mzid = mz_name;
681 entry->from = from;
682 entry->to = to;
683
684 if (mzMappings == NULL) {
685 mzMappings = new UVector(deleteOlsonToMetaMappingEntry, NULL, status);
686 if (U_FAILURE(status)) {
687 delete mzMappings;
688 deleteOlsonToMetaMappingEntry(entry);
689 uprv_free(entry);
690 break;
691 }
692 }
693
694 mzMappings->addElement(entry, status);
695 if (U_FAILURE(status)) {
696 break;
697 }
698 }
699 ures_close(mz);
700 if (U_FAILURE(status)) {
701 if (mzMappings != NULL) {
702 delete mzMappings;
703 mzMappings = NULL;
704 }
705 }
706 }
707 }
708 ures_close(rb);
709 return mzMappings;
710 }
711
712 UnicodeString& U_EXPORT2
713 ZoneMeta::getZoneIdByMetazone(const UnicodeString &mzid, const UnicodeString &region, UnicodeString &result) {
714 UErrorCode status = U_ZERO_ERROR;
715 const UChar *tzid = NULL;
716 int32_t tzidLen = 0;
717 char keyBuf[ZID_KEY_MAX + 1];
718 int32_t keyLen = 0;
719
720 if (mzid.length() > ZID_KEY_MAX) {
721 result.setToBogus();
722 return result;
723 }
724
725 keyLen = mzid.extract(0, mzid.length(), keyBuf, ZID_KEY_MAX + 1, US_INV);
726 keyBuf[keyLen] = 0;
727
728 UResourceBundle *rb = ures_openDirect(NULL, gMetaZones, &status);
729 ures_getByKey(rb, gMapTimezonesTag, rb, &status);
730 ures_getByKey(rb, keyBuf, rb, &status);
731
732 if (U_SUCCESS(status)) {
733 // check region mapping
734 if (region.length() == 2 || region.length() == 3) {
735 keyLen = region.extract(0, region.length(), keyBuf, ZID_KEY_MAX + 1, US_INV);
736 keyBuf[keyLen] = 0;
737 tzid = ures_getStringByKey(rb, keyBuf, &tzidLen, &status);
738 if (status == U_MISSING_RESOURCE_ERROR) {
739 status = U_ZERO_ERROR;
740 }
741 }
742 if (U_SUCCESS(status) && tzid == NULL) {
743 // try "001"
744 tzid = ures_getStringByKey(rb, gWorldTag, &tzidLen, &status);
745 }
746 }
747 ures_close(rb);
748
749 if (tzid == NULL) {
750 result.setToBogus();
751 } else {
752 result.setTo(tzid, tzidLen);
753 }
754
755 return result;
756 }
757
758 static void U_CALLCONV initAvailableMetaZoneIDs () {
759 U_ASSERT(gMetaZoneIDs == NULL);
760 U_ASSERT(gMetaZoneIDTable == NULL);
761 ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);
762
763 UErrorCode status = U_ZERO_ERROR;
764 gMetaZoneIDTable = uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, NULL, &status);
765 if (U_FAILURE(status) || gMetaZoneIDTable == NULL) {
766 gMetaZoneIDTable = NULL;
767 return;
768 }
769 uhash_setKeyDeleter(gMetaZoneIDTable, uprv_deleteUObject);
770 // No valueDeleter, because the vector maintain the value objects
771 gMetaZoneIDs = new UVector(NULL, uhash_compareUChars, status);
772 if (U_FAILURE(status) || gMetaZoneIDs == NULL) {
773 gMetaZoneIDs = NULL;
774 uhash_close(gMetaZoneIDTable);
775 gMetaZoneIDTable = NULL;
776 return;
777 }
778 gMetaZoneIDs->setDeleter(uprv_free);
779
780 UResourceBundle *rb = ures_openDirect(NULL, gMetaZones, &status);
781 UResourceBundle *bundle = ures_getByKey(rb, gMapTimezonesTag, NULL, &status);
782 UResourceBundle res;
783 ures_initStackObject(&res);
784 while (U_SUCCESS(status) && ures_hasNext(bundle)) {
785 ures_getNextResource(bundle, &res, &status);
786 if (U_FAILURE(status)) {
787 break;
788 }
789 const char *mzID = ures_getKey(&res);
790 int32_t len = uprv_strlen(mzID);
791 UChar *uMzID = (UChar*)uprv_malloc(sizeof(UChar) * (len + 1));
792 if (uMzID == NULL) {
793 status = U_MEMORY_ALLOCATION_ERROR;
794 break;
795 }
796 u_charsToUChars(mzID, uMzID, len);
797 uMzID[len] = 0;
798 UnicodeString *usMzID = new UnicodeString(uMzID);
799 if (uhash_get(gMetaZoneIDTable, usMzID) == NULL) {
800 gMetaZoneIDs->addElement((void *)uMzID, status);
801 uhash_put(gMetaZoneIDTable, (void *)usMzID, (void *)uMzID, &status);
802 } else {
803 uprv_free(uMzID);
804 delete usMzID;
805 }
806 }
807 ures_close(&res);
808 ures_close(bundle);
809 ures_close(rb);
810
811 if (U_FAILURE(status)) {
812 uhash_close(gMetaZoneIDTable);
813 delete gMetaZoneIDs;
814 gMetaZoneIDTable = NULL;
815 gMetaZoneIDs = NULL;
816 }
817 }
818
819 const UVector*
820 ZoneMeta::getAvailableMetazoneIDs() {
821 umtx_initOnce(gMetaZoneIDsInitOnce, &initAvailableMetaZoneIDs);
822 return gMetaZoneIDs;
823 }
824
825 const UChar*
826 ZoneMeta::findMetaZoneID(const UnicodeString& mzid) {
827 umtx_initOnce(gMetaZoneIDsInitOnce, &initAvailableMetaZoneIDs);
828 if (gMetaZoneIDTable == NULL) {
829 return NULL;
830 }
831 return (const UChar*)uhash_get(gMetaZoneIDTable, &mzid);
832 }
833
834 const UChar*
835 ZoneMeta::findTimeZoneID(const UnicodeString& tzid) {
836 return TimeZone::findID(tzid);
837 }
838
839
840 TimeZone*
841 ZoneMeta::createCustomTimeZone(int32_t offset) {
842 UBool negative = FALSE;
843 int32_t tmp = offset;
844 if (offset < 0) {
845 negative = TRUE;
846 tmp = -offset;
847 }
848 int32_t hour, min, sec;
849
850 tmp /= 1000;
851 sec = tmp % 60;
852 tmp /= 60;
853 min = tmp % 60;
854 hour = tmp / 60;
855
856 UnicodeString zid;
857 formatCustomID(hour, min, sec, negative, zid);
858 return new SimpleTimeZone(offset, zid);
859 }
860
861 UnicodeString&
862 ZoneMeta::formatCustomID(uint8_t hour, uint8_t min, uint8_t sec, UBool negative, UnicodeString& id) {
863 // Create normalized time zone ID - GMT[+|-]HH:mm[:ss]
864 id.setTo(gCustomTzPrefix, -1);
865 if (hour != 0 || min != 0) {
866 if (negative) {
867 id.append((UChar)0x2D); // '-'
868 } else {
869 id.append((UChar)0x2B); // '+'
870 }
871 // Always use US-ASCII digits
872 id.append((UChar)(0x30 + (hour%100)/10));
873 id.append((UChar)(0x30 + (hour%10)));
874 id.append((UChar)0x3A); // ':'
875 id.append((UChar)(0x30 + (min%100)/10));
876 id.append((UChar)(0x30 + (min%10)));
877 if (sec != 0) {
878 id.append((UChar)0x3A); // ':'
879 id.append((UChar)(0x30 + (sec%100)/10));
880 id.append((UChar)(0x30 + (sec%10)));
881 }
882 }
883 return id;
884 }
885
886 const UChar*
887 ZoneMeta::getShortID(const TimeZone& tz) {
888 const UChar* canonicalID = NULL;
889 if (dynamic_cast<const OlsonTimeZone *>(&tz) != NULL) {
890 // short cut for OlsonTimeZone
891 const OlsonTimeZone *otz = (const OlsonTimeZone*)&tz;
892 canonicalID = otz->getCanonicalID();
893 }
894 if (canonicalID == NULL) {
895 return NULL;
896 }
897 return getShortIDFromCanonical(canonicalID);
898 }
899
900 const UChar*
901 ZoneMeta::getShortID(const UnicodeString& id) {
902 UErrorCode status = U_ZERO_ERROR;
903 const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(id, status);
904 if (U_FAILURE(status) || canonicalID == NULL) {
905 return NULL;
906 }
907 return ZoneMeta::getShortIDFromCanonical(canonicalID);
908 }
909
910 const UChar*
911 ZoneMeta::getShortIDFromCanonical(const UChar* canonicalID) {
912 const UChar* shortID = NULL;
913 int32_t len = u_strlen(canonicalID);
914 char tzidKey[ZID_KEY_MAX + 1];
915
916 u_UCharsToChars(canonicalID, tzidKey, len);
917 tzidKey[len] = (char) 0; // Make sure it is null terminated.
918
919 // replace '/' with ':'
920 char *p = tzidKey;
921 while (*p++) {
922 if (*p == '/') {
923 *p = ':';
924 }
925 }
926
927 UErrorCode status = U_ZERO_ERROR;
928 UResourceBundle *rb = ures_openDirect(NULL, gKeyTypeData, &status);
929 ures_getByKey(rb, gTypeMapTag, rb, &status);
930 ures_getByKey(rb, gTimezoneTag, rb, &status);
931 shortID = ures_getStringByKey(rb, tzidKey, NULL, &status);
932 ures_close(rb);
933
934 return shortID;
935 }
936
937 U_NAMESPACE_END
938
939 #endif /* #if !UCONFIG_NO_FORMATTING */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial