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