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