ICU-57131.0.1.tar.gz

[apple/icu.git] / icuSources / i18n / zonemeta.cpp

diff --git a/icuSources/i18n/zonemeta.cpp b/icuSources/i18n/zonemeta.cpp
index e244f9c2f82463cb504e303fb1becd22c81fc552..e2c75e5577b503499895a78c50e0e2c079f01970 100644 (file)
--- a/icuSources/i18n/zonemeta.cpp
+++ b/icuSources/i18n/zonemeta.cpp
@@ -1,7 +1,7 @@
 /*
 *******************************************************************************
 /*
 *******************************************************************************

-* Copyright (C) 2007-2012, International Business Machines Corporation and    *
-* others. All Rights Reserved.                                                *
+* Copyright (C) 2007-2014, International Business Machines Corporation and
+* others. All Rights Reserved.

 *******************************************************************************
 */
 
 *******************************************************************************
 */
 


@@ -27,25 +27,25 @@
 #include "uhash.h"
 #include "olsontz.h"
 
 #include "uhash.h"
 #include "olsontz.h"
 

-static UMTX gZoneMetaLock = NULL;
+static UMutex gZoneMetaLock = U_MUTEX_INITIALIZER;

 
 // CLDR Canonical ID mapping table
 static UHashtable *gCanonicalIDCache = NULL;
 
 // CLDR Canonical ID mapping table
 static UHashtable *gCanonicalIDCache = NULL;

-static UBool gCanonicalIDCacheInitialized = FALSE;
+static icu::UInitOnce gCanonicalIDCacheInitOnce = U_INITONCE_INITIALIZER;

 
 // Metazone mapping table
 static UHashtable *gOlsonToMeta = NULL;
 
 // Metazone mapping table
 static UHashtable *gOlsonToMeta = NULL;

-static UBool gOlsonToMetaInitialized = FALSE;
+static icu::UInitOnce gOlsonToMetaInitOnce = U_INITONCE_INITIALIZER;

 
 // Available metazone IDs vector and table
 static icu::UVector *gMetaZoneIDs = NULL;
 static UHashtable *gMetaZoneIDTable = NULL;
 
 // Available metazone IDs vector and table
 static icu::UVector *gMetaZoneIDs = NULL;
 static UHashtable *gMetaZoneIDTable = NULL;

-static UBool gMetaZoneIDsInitialized = FALSE;
+static icu::UInitOnce gMetaZoneIDsInitOnce = U_INITONCE_INITIALIZER;

 
 // Country info vectors
 static icu::UVector *gSingleZoneCountries = NULL;
 static icu::UVector *gMultiZonesCountries = NULL;
 
 // Country info vectors
 static icu::UVector *gSingleZoneCountries = NULL;
 static icu::UVector *gMultiZonesCountries = NULL;

-static UBool gCountryInfoVectorsInitialized = FALSE;
+static icu::UInitOnce gCountryInfoVectorsInitOnce = U_INITONCE_INITIALIZER;

 
 U_CDECL_BEGIN
 
 
 U_CDECL_BEGIN
 


@@ -54,31 +54,33 @@ U_CDECL_BEGIN
  */
 static UBool U_CALLCONV zoneMeta_cleanup(void)
 {
  */
 static UBool U_CALLCONV zoneMeta_cleanup(void)
 {

-    umtx_destroy(&gZoneMetaLock);
-

     if (gCanonicalIDCache != NULL) {
         uhash_close(gCanonicalIDCache);
         gCanonicalIDCache = NULL;
     }
     if (gCanonicalIDCache != NULL) {
         uhash_close(gCanonicalIDCache);
         gCanonicalIDCache = NULL;
     }

-    gCanonicalIDCacheInitialized = FALSE;
+    gCanonicalIDCacheInitOnce.reset();

 
     if (gOlsonToMeta != NULL) {
         uhash_close(gOlsonToMeta);
         gOlsonToMeta = NULL;
     }
 
     if (gOlsonToMeta != NULL) {
         uhash_close(gOlsonToMeta);
         gOlsonToMeta = NULL;
     }

-    gOlsonToMetaInitialized = FALSE;
+    gOlsonToMetaInitOnce.reset();

 
     if (gMetaZoneIDTable != NULL) {
         uhash_close(gMetaZoneIDTable);
 
     if (gMetaZoneIDTable != NULL) {
         uhash_close(gMetaZoneIDTable);

+        gMetaZoneIDTable = NULL;

     }
     // delete after closing gMetaZoneIDTable, because it holds
     // value objects held by the hashtable
     delete gMetaZoneIDs;
     }
     // delete after closing gMetaZoneIDTable, because it holds
     // value objects held by the hashtable
     delete gMetaZoneIDs;

-    gMetaZoneIDsInitialized = FALSE;
+    gMetaZoneIDs = NULL;
+    gMetaZoneIDsInitOnce.reset();

 
     delete gSingleZoneCountries;
 
     delete gSingleZoneCountries;

+    gSingleZoneCountries = NULL;

     delete gMultiZonesCountries;
     delete gMultiZonesCountries;

-    gCountryInfoVectorsInitialized = FALSE;
+    gMultiZonesCountries = NULL;
+    gCountryInfoVectorsInitOnce.reset();

 
     return TRUE;
 }
 
     return TRUE;
 }


@@ -119,11 +121,13 @@ static const char gMetaZones[]          = "metaZones";
 static const char gMetazoneInfo[]       = "metazoneInfo";
 static const char gMapTimezonesTag[]    = "mapTimezones";
 
 static const char gMetazoneInfo[]       = "metazoneInfo";
 static const char gMapTimezonesTag[]    = "mapTimezones";
 

-static const char gTimeZoneTypes[]      = "timezoneTypes";
+static const char gKeyTypeData[]        = "keyTypeData";

 static const char gTypeAliasTag[]       = "typeAlias";
 static const char gTypeMapTag[]         = "typeMap";
 static const char gTimezoneTag[]        = "timezone";
 
 static const char gTypeAliasTag[]       = "typeAlias";
 static const char gTypeMapTag[]         = "typeMap";
 static const char gTimezoneTag[]        = "timezone";
 

+static const char gPrimaryZonesTag[]    = "primaryZones";
+

 static const char gWorldTag[]           = "001";
 
 static const UChar gWorld[] = {0x30, 0x30, 0x31, 0x00}; // "001"
 static const char gWorldTag[]           = "001";
 
 static const UChar gWorld[] = {0x30, 0x30, 0x31, 0x00}; // "001"


@@ -212,40 +216,34 @@ parseDate (const UChar *text, UErrorCode &status) {
     return 0;
 }
 
     return 0;
 }
 

+static void U_CALLCONV initCanonicalIDCache(UErrorCode &status) {
+    gCanonicalIDCache = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status);
+    if (gCanonicalIDCache == NULL) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+    }
+    if (U_FAILURE(status)) {
+        gCanonicalIDCache = NULL;
+    }
+    // No key/value deleters - keys/values are from a resource bundle
+    ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);
+}
+
+

 const UChar* U_EXPORT2
 ZoneMeta::getCanonicalCLDRID(const UnicodeString &tzid, UErrorCode& status) {
     if (U_FAILURE(status)) {
         return NULL;
     }
 
 const UChar* U_EXPORT2
 ZoneMeta::getCanonicalCLDRID(const UnicodeString &tzid, UErrorCode& status) {
     if (U_FAILURE(status)) {
         return NULL;
     }
 

-    int32_t len = tzid.length();
-    if (len > ZID_KEY_MAX) {
+    if (tzid.isBogus() || tzid.length() > ZID_KEY_MAX) {

         status = U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;
     }
 
     // Checking the cached results
         status = U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;
     }
 
     // Checking the cached results

-    UBool initialized;
-    UMTX_CHECK(&gZoneMetaLock, gCanonicalIDCacheInitialized, initialized);
-    if (!initialized) {
-        // Create empty hashtable
-        umtx_lock(&gZoneMetaLock);
-        {
-            if (!gCanonicalIDCacheInitialized) {
-                gCanonicalIDCache = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status);
-                if (gCanonicalIDCache == NULL) {
-                    status = U_MEMORY_ALLOCATION_ERROR;
-                }
-                if (U_FAILURE(status)) {
-                    gCanonicalIDCache = NULL;
-                    return NULL;
-                }
-                // No key/value deleters - keys/values are from a resource bundle
-                gCanonicalIDCacheInitialized = TRUE;
-                ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);
-            }
-        }
-        umtx_unlock(&gZoneMetaLock);
+    umtx_initOnce(gCanonicalIDCacheInitOnce, &initCanonicalIDCache, status);
+    if (U_FAILURE(status)) {
+        return NULL;

     }
 
     const UChar *canonicalID = NULL;
     }
 
     const UChar *canonicalID = NULL;


@@ -269,10 +267,7 @@ ZoneMeta::getCanonicalCLDRID(const UnicodeString &tzid, UErrorCode& status) {
     // If not, resolve CLDR canonical ID with resource data
     UBool isInputCanonical = FALSE;
     char id[ZID_KEY_MAX + 1];
     // If not, resolve CLDR canonical ID with resource data
     UBool isInputCanonical = FALSE;
     char id[ZID_KEY_MAX + 1];

-    const UChar* idChars = tzid.getBuffer();
-
-    u_UCharsToChars(idChars,id,len);
-    id[len] = (char) 0; // Make sure it is null terminated.
+    tzid.extract(0, 0x7fffffff, id, UPRV_LENGTHOF(id), US_INV);

 
     // replace '/' with ':'
     char *p = id;
 
     // replace '/' with ':'
     char *p = id;


@@ -282,7 +277,7 @@ ZoneMeta::getCanonicalCLDRID(const UnicodeString &tzid, UErrorCode& status) {
         }
     }
 
         }
     }
 

-    UResourceBundle *top = ures_openDirect(NULL, gTimeZoneTypes, &tmpStatus);
+    UResourceBundle *top = ures_openDirect(NULL, gKeyTypeData, &tmpStatus);

     UResourceBundle *rb = ures_getByKey(top, gTypeMapTag, NULL, &tmpStatus);
     ures_getByKey(rb, gTimezoneTag, rb, &tmpStatus);
     ures_getByKey(rb, id, rb, &tmpStatus);
     UResourceBundle *rb = ures_getByKey(top, gTypeMapTag, NULL, &tmpStatus);
     ures_getByKey(rb, gTimezoneTag, rb, &tmpStatus);
     ures_getByKey(rb, id, rb, &tmpStatus);


@@ -310,7 +305,7 @@ ZoneMeta::getCanonicalCLDRID(const UnicodeString &tzid, UErrorCode& status) {
             if (derefer == NULL) {
                 status = U_ILLEGAL_ARGUMENT_ERROR;
             } else {
             if (derefer == NULL) {
                 status = U_ILLEGAL_ARGUMENT_ERROR;
             } else {

-                len = u_strlen(derefer);
+                int32_t len = u_strlen(derefer);

                 u_UCharsToChars(derefer,id,len);
                 id[len] = (char) 0; // Make sure it is null terminated.
 
                 u_UCharsToChars(derefer,id,len);
                 id[len] = (char) 0; // Make sure it is null terminated.
 


@@ -393,121 +388,128 @@ ZoneMeta::getCanonicalCLDRID(const TimeZone& tz) {
     return getCanonicalCLDRID(tz.getID(tzID), status);
 }
 
     return getCanonicalCLDRID(tz.getID(tzID), status);
 }
 

+static void U_CALLCONV countryInfoVectorsInit(UErrorCode &status) {
+    // Create empty vectors
+    // No deleters for these UVectors, it's a reference to a resource bundle string.
+    gSingleZoneCountries = new UVector(NULL, uhash_compareUChars, status);
+    if (gSingleZoneCountries == NULL) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+    }
+    gMultiZonesCountries = new UVector(NULL, uhash_compareUChars, status);
+    if (gMultiZonesCountries == NULL) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+    }

 
 

-
-UnicodeString& U_EXPORT2
-ZoneMeta::getCanonicalCountry(const UnicodeString &tzid, UnicodeString &canonicalCountry) {
-    const UChar *region = TimeZone::getRegion(tzid);
-    if (region != NULL && u_strcmp(gWorld, region) != 0) {
-        canonicalCountry.setTo(region, -1);
-    } else {
-        canonicalCountry.setToBogus();
+    if (U_FAILURE(status)) {
+        delete gSingleZoneCountries;
+        delete gMultiZonesCountries;
+        gSingleZoneCountries = NULL;
+        gMultiZonesCountries  = NULL;

     }
     }

-    return canonicalCountry;
+    ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);

 }
 
 }
 

+

 UnicodeString& U_EXPORT2
 UnicodeString& U_EXPORT2

-ZoneMeta::getSingleCountry(const UnicodeString &tzid, UnicodeString &country) {
-    // Get canonical country for the zone
+ZoneMeta::getCanonicalCountry(const UnicodeString &tzid, UnicodeString &country, UBool *isPrimary /* = NULL */) {
+    if (isPrimary != NULL) {
+        *isPrimary = FALSE;
+    }
+

     const UChar *region = TimeZone::getRegion(tzid);
     const UChar *region = TimeZone::getRegion(tzid);

-    if (region == NULL || u_strcmp(gWorld, region) == 0) {
-        // special case - unknown or "001"
+    if (region != NULL && u_strcmp(gWorld, region) != 0) {
+        country.setTo(region, -1);
+    } else {

         country.setToBogus();
         return country;
     }
 
         country.setToBogus();
         return country;
     }
 

-    // Checking the cached results
-    UErrorCode status = U_ZERO_ERROR;
-    UBool initialized;
-    UMTX_CHECK(&gZoneMetaLock, gCountryInfoVectorsInitialized, initialized);
-    if (!initialized) {
-        // Create empty vectors
-        umtx_lock(&gZoneMetaLock);
-        {
-            if (!gCountryInfoVectorsInitialized) {
-                // No deleters for these UVectors, it's a reference to a resource bundle string.
-                gSingleZoneCountries = new UVector(NULL, uhash_compareUChars, status);
-                if (gSingleZoneCountries == NULL) {
-                    status = U_MEMORY_ALLOCATION_ERROR;
-                }
-                gMultiZonesCountries = new UVector(NULL, uhash_compareUChars, status);
-                if (gMultiZonesCountries == NULL) {
-                    status = U_MEMORY_ALLOCATION_ERROR;
-                }
-
-                if (U_SUCCESS(status)) {
-                    gCountryInfoVectorsInitialized = TRUE;
-                } else {
-                    delete gSingleZoneCountries;
-                    delete gMultiZonesCountries;
-                }
-            }
-        }
-        umtx_unlock(&gZoneMetaLock);
+    if (isPrimary != NULL) {
+        char regionBuf[] = {0, 0, 0};

 
 

+        // Checking the cached results
+        UErrorCode status = U_ZERO_ERROR;
+        umtx_initOnce(gCountryInfoVectorsInitOnce, &countryInfoVectorsInit, status);

         if (U_FAILURE(status)) {
         if (U_FAILURE(status)) {

-            country.setToBogus();

             return country;
         }
             return country;
         }

-        U_ASSERT(gSingleZoneCountries != NULL);
-        U_ASSERT(gMultiZonesCountries != NULL);
-    }

 
 

-    // Check if it was already cached
-    UBool cached = FALSE;
-    UBool multiZones = FALSE;
-    umtx_lock(&gZoneMetaLock);
-    {
-        multiZones = cached = gMultiZonesCountries->contains((void*)region);
-        if (!multiZones) {
-            cached = gSingleZoneCountries->contains((void*)region);
+        // Check if it was already cached
+        UBool cached = FALSE;
+        UBool singleZone = FALSE;
+        umtx_lock(&gZoneMetaLock);
+        {
+            singleZone = cached = gSingleZoneCountries->contains((void*)region);
+            if (!cached) {
+                cached = gMultiZonesCountries->contains((void*)region);
+            }

         }
         }

-    }
-    umtx_unlock(&gZoneMetaLock);
+        umtx_unlock(&gZoneMetaLock);

 
 

-    if (!cached) {
-        // We need to go through all zones associated with the region.
-        // This is relatively heavy operation.
+        if (!cached) {
+            // We need to go through all zones associated with the region.
+            // This is relatively heavy operation.

 
 

-        U_ASSERT(u_strlen(region) == 2);
+            U_ASSERT(u_strlen(region) == 2);

 
 

-        char buf[] = {0, 0, 0};
-        u_UCharsToChars(region, buf, 2);
+            u_UCharsToChars(region, regionBuf, 2);

 
 

-        StringEnumeration *ids = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL_LOCATION, buf, NULL, status);
-        int32_t idsLen = ids->count(status);
-        if (U_SUCCESS(status) && idsLen > 1) {
-            // multiple canonical zones are available for the region
-            multiZones = TRUE;
-        }
-        if (U_FAILURE(status)) {
-            // no single country by default for any error cases
-            multiZones = TRUE;
+            StringEnumeration *ids = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL_LOCATION, regionBuf, NULL, status);
+            int32_t idsLen = ids->count(status);
+            if (U_SUCCESS(status) && idsLen == 1) {
+                // only the single zone is available for the region
+                singleZone = TRUE;
+            }
+            delete ids;
+
+            // Cache the result
+            umtx_lock(&gZoneMetaLock);
+            {
+                UErrorCode ec = U_ZERO_ERROR;
+                if (singleZone) {
+                    if (!gSingleZoneCountries->contains((void*)region)) {
+                        gSingleZoneCountries->addElement((void*)region, ec);
+                    }
+                } else {
+                    if (!gMultiZonesCountries->contains((void*)region)) {
+                        gMultiZonesCountries->addElement((void*)region, ec);
+                    }
+                }
+            }
+            umtx_unlock(&gZoneMetaLock);

         }
         }

-        delete ids;

 
 

-        // Cache the result
-        umtx_lock(&gZoneMetaLock);
-        {
-            UErrorCode ec = U_ZERO_ERROR;
-            if (multiZones) {
-                if (!gMultiZonesCountries->contains((void*)region)) {
-                    gMultiZonesCountries->addElement((void*)region, ec);
-                }
-            } else {
-                if (!gSingleZoneCountries->contains((void*)region)) {
-                    gSingleZoneCountries->addElement((void*)region, ec);
+        if (singleZone) {
+            *isPrimary = TRUE;
+        } else {
+            // Note: We may cache the primary zone map in future.
+
+            // Even a country has multiple zones, one of them might be
+            // dominant and treated as a primary zone
+            int32_t idLen = 0;
+            if (regionBuf[0] == 0) {
+                u_UCharsToChars(region, regionBuf, 2);
+            }
+
+            UResourceBundle *rb = ures_openDirect(NULL, gMetaZones, &status);
+            ures_getByKey(rb, gPrimaryZonesTag, rb, &status);
+            const UChar *primaryZone = ures_getStringByKey(rb, regionBuf, &idLen, &status);
+            if (U_SUCCESS(status)) {
+                if (tzid.compare(primaryZone, idLen) == 0) {
+                    *isPrimary = TRUE;
+                } else {
+                    // The given ID might not be a canonical ID
+                    UnicodeString canonicalID;
+                    TimeZone::getCanonicalID(tzid, canonicalID, status);
+                    if (U_SUCCESS(status) && canonicalID.compare(primaryZone, idLen) == 0) {
+                        *isPrimary = TRUE;
+                    }

                 }
             }
                 }
             }

+            ures_close(rb);

         }
         }

-        umtx_unlock(&gZoneMetaLock);

     }
 
     }
 

-    if (multiZones) {
-        country.setToBogus();
-    } else {
-        country.setTo(region, -1);
-    }

     return country;
 }
 
     return country;
 }
 


@@ -531,6 +533,19 @@ ZoneMeta::getMetazoneID(const UnicodeString &tzid, UDate date, UnicodeString &re
     return result;
 }
 
     return result;
 }
 

+static void U_CALLCONV olsonToMetaInit(UErrorCode &status) {
+    U_ASSERT(gOlsonToMeta == NULL);
+    ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);
+    gOlsonToMeta = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status);
+    if (U_FAILURE(status)) {
+        gOlsonToMeta = NULL;
+    } else {
+        uhash_setKeyDeleter(gOlsonToMeta, deleteUCharString);
+        uhash_setValueDeleter(gOlsonToMeta, deleteUVector);
+    }
+}
+
+

 const UVector* U_EXPORT2
 ZoneMeta::getMetazoneMappings(const UnicodeString &tzid) {
     UErrorCode status = U_ZERO_ERROR;
 const UVector* U_EXPORT2
 ZoneMeta::getMetazoneMappings(const UnicodeString &tzid) {
     UErrorCode status = U_ZERO_ERROR;


@@ -540,31 +555,9 @@ ZoneMeta::getMetazoneMappings(const UnicodeString &tzid) {
         return NULL;
     }
 
         return NULL;
     }
 

-    UBool initialized;
-    UMTX_CHECK(&gZoneMetaLock, gOlsonToMetaInitialized, initialized);
-    if (!initialized) {
-        UHashtable *tmpOlsonToMeta = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status);
-        if (U_FAILURE(status)) {
-            return NULL;
-        }
-        uhash_setKeyDeleter(tmpOlsonToMeta, deleteUCharString);
-        uhash_setValueDeleter(tmpOlsonToMeta, deleteUVector);
-
-        umtx_lock(&gZoneMetaLock);
-        {
-            if (!gOlsonToMetaInitialized) {
-                gOlsonToMeta = tmpOlsonToMeta;
-                tmpOlsonToMeta = NULL;
-                gOlsonToMetaInitialized = TRUE;
-            }
-        }
-        umtx_unlock(&gZoneMetaLock);
-
-        // OK to call the following multiple times with the same function
-        ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);
-        if (tmpOlsonToMeta != NULL) {
-            uhash_close(tmpOlsonToMeta);
-        }
+    umtx_initOnce(gOlsonToMetaInitOnce, &olsonToMetaInit, status);
+    if (U_FAILURE(status)) {
+        return NULL;

     }
 
     // get the mapping from cache
     }
 
     // get the mapping from cache


@@ -720,7 +713,7 @@ ZoneMeta::getZoneIdByMetazone(const UnicodeString &mzid, const UnicodeString &re
     char keyBuf[ZID_KEY_MAX + 1];
     int32_t keyLen = 0;
 
     char keyBuf[ZID_KEY_MAX + 1];
     int32_t keyLen = 0;
 

-    if (mzid.length() > ZID_KEY_MAX) {
+    if (mzid.isBogus() || mzid.length() > ZID_KEY_MAX) {

         result.setToBogus();
         return result;
     }
         result.setToBogus();
         return result;
     }


@@ -758,85 +751,79 @@ ZoneMeta::getZoneIdByMetazone(const UnicodeString &mzid, const UnicodeString &re
     return result;
 }
 
     return result;
 }
 

-void
-ZoneMeta::initAvailableMetaZoneIDs () {
-    UBool initialized;
-    UMTX_CHECK(&gZoneMetaLock, gMetaZoneIDsInitialized, initialized);
-    if (!initialized) {
-        umtx_lock(&gZoneMetaLock);
-        {
-            if (!gMetaZoneIDsInitialized) {
-                UErrorCode status = U_ZERO_ERROR;
-                UHashtable *metaZoneIDTable = uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, NULL, &status);
-                uhash_setKeyDeleter(metaZoneIDTable, uprv_deleteUObject);
-                // No valueDeleter, because the vector maintain the value objects
-                UVector *metaZoneIDs = NULL;
-                if (U_SUCCESS(status)) {
-                    metaZoneIDs = new UVector(NULL, uhash_compareUChars, status);
-                    if (metaZoneIDs == NULL) {
-                        status = U_MEMORY_ALLOCATION_ERROR;
-                    }
-                } else {
-                    uhash_close(metaZoneIDTable);
-                }
-                if (U_SUCCESS(status)) {
-                    U_ASSERT(metaZoneIDs != NULL);
-                    metaZoneIDs->setDeleter(uprv_free);
-
-                    UResourceBundle *rb = ures_openDirect(NULL, gMetaZones, &status);
-                    UResourceBundle *bundle = ures_getByKey(rb, gMapTimezonesTag, NULL, &status);
-                    UResourceBundle res;
-                    ures_initStackObject(&res);
-                    while (U_SUCCESS(status) && ures_hasNext(bundle)) {
-                        ures_getNextResource(bundle, &res, &status);
-                        if (U_FAILURE(status)) {
-                            break;
-                        }
-                        const char *mzID = ures_getKey(&res);
-                        int32_t len = uprv_strlen(mzID);
-                        UChar *uMzID = (UChar*)uprv_malloc(sizeof(UChar) * (len + 1));
-                        if (uMzID == NULL) {
-                            status = U_MEMORY_ALLOCATION_ERROR;
-                            break;
-                        }
-                        u_charsToUChars(mzID, uMzID, len);
-                        uMzID[len] = 0;
-                        UnicodeString *usMzID = new UnicodeString(uMzID);
-                        if (uhash_get(metaZoneIDTable, usMzID) == NULL) {
-                            metaZoneIDs->addElement((void *)uMzID, status);
-                            uhash_put(metaZoneIDTable, (void *)usMzID, (void *)uMzID, &status);
-                        } else {
-                            uprv_free(uMzID);
-                            delete usMzID;
-                        }
-                    }
-                    if (U_SUCCESS(status)) {
-                        gMetaZoneIDs = metaZoneIDs;
-                        gMetaZoneIDTable = metaZoneIDTable;
-                        gMetaZoneIDsInitialized = TRUE;
-                    } else {
-                        uhash_close(metaZoneIDTable);
-                        delete metaZoneIDs;
-                    }
-                    ures_close(&res);
-                    ures_close(bundle);
-                    ures_close(rb);
-                }
-            }
+static void U_CALLCONV initAvailableMetaZoneIDs () {
+    U_ASSERT(gMetaZoneIDs == NULL);
+    U_ASSERT(gMetaZoneIDTable == NULL);
+    ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);
+
+    UErrorCode status = U_ZERO_ERROR;
+    gMetaZoneIDTable = uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, NULL, &status);
+    if (U_FAILURE(status) || gMetaZoneIDTable == NULL) {
+        gMetaZoneIDTable = NULL;
+        return;
+    }
+    uhash_setKeyDeleter(gMetaZoneIDTable, uprv_deleteUObject);
+    // No valueDeleter, because the vector maintain the value objects
+    gMetaZoneIDs = new UVector(NULL, uhash_compareUChars, status);
+    if (U_FAILURE(status) || gMetaZoneIDs == NULL) {
+        gMetaZoneIDs = NULL;
+        uhash_close(gMetaZoneIDTable);
+        gMetaZoneIDTable = NULL;
+        return;
+    }
+    gMetaZoneIDs->setDeleter(uprv_free);
+
+    UResourceBundle *rb = ures_openDirect(NULL, gMetaZones, &status);
+    UResourceBundle *bundle = ures_getByKey(rb, gMapTimezonesTag, NULL, &status);
+    UResourceBundle res;
+    ures_initStackObject(&res);
+    while (U_SUCCESS(status) && ures_hasNext(bundle)) {
+        ures_getNextResource(bundle, &res, &status);
+        if (U_FAILURE(status)) {
+            break;

         }
         }

-        umtx_unlock(&gZoneMetaLock);
+        const char *mzID = ures_getKey(&res);
+        int32_t len = uprv_strlen(mzID);
+        UChar *uMzID = (UChar*)uprv_malloc(sizeof(UChar) * (len + 1));
+        if (uMzID == NULL) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            break;
+        }
+        u_charsToUChars(mzID, uMzID, len);
+        uMzID[len] = 0;
+        UnicodeString *usMzID = new UnicodeString(uMzID);
+        if (uhash_get(gMetaZoneIDTable, usMzID) == NULL) {
+            gMetaZoneIDs->addElement((void *)uMzID, status);
+            uhash_put(gMetaZoneIDTable, (void *)usMzID, (void *)uMzID, &status);
+        } else {
+            uprv_free(uMzID);
+            delete usMzID;
+        }
+    }
+    ures_close(&res);
+    ures_close(bundle);
+    ures_close(rb);
+
+    if (U_FAILURE(status)) {
+        uhash_close(gMetaZoneIDTable);
+        delete gMetaZoneIDs;
+        gMetaZoneIDTable = NULL;
+        gMetaZoneIDs = NULL;

     }
 }
 
 const UVector*
 ZoneMeta::getAvailableMetazoneIDs() {
     }
 }
 
 const UVector*
 ZoneMeta::getAvailableMetazoneIDs() {

-    initAvailableMetaZoneIDs();
+    umtx_initOnce(gMetaZoneIDsInitOnce, &initAvailableMetaZoneIDs);

     return gMetaZoneIDs;
 }
 
 const UChar*
 ZoneMeta::findMetaZoneID(const UnicodeString& mzid) {
     return gMetaZoneIDs;
 }
 
 const UChar*
 ZoneMeta::findMetaZoneID(const UnicodeString& mzid) {

-    initAvailableMetaZoneIDs();
+    umtx_initOnce(gMetaZoneIDsInitOnce, &initAvailableMetaZoneIDs);
+    if (gMetaZoneIDTable == NULL) {
+        return NULL;
+    }

     return (const UChar*)uhash_get(gMetaZoneIDTable, &mzid);
 }
 
     return (const UChar*)uhash_get(gMetaZoneIDTable, &mzid);
 }
 


@@ -873,25 +860,75 @@ ZoneMeta::formatCustomID(uint8_t hour, uint8_t min, uint8_t sec, UBool negative,
     id.setTo(gCustomTzPrefix, -1);
     if (hour != 0 || min != 0) {
         if (negative) {
     id.setTo(gCustomTzPrefix, -1);
     if (hour != 0 || min != 0) {
         if (negative) {

-            id.append(0x2D);    // '-'
+          id.append((UChar)0x2D);    // '-'

         } else {
         } else {

-            id.append(0x2B);    // '+'
+          id.append((UChar)0x2B);    // '+'

         }
         // Always use US-ASCII digits
         }
         // Always use US-ASCII digits

-        id.append(0x30 + (hour%100)/10);
-        id.append(0x30 + (hour%10));
-        id.append(0x3A);    // ':'
-        id.append(0x30 + (min%100)/10);
-        id.append(0x30 + (min%10));
+        id.append((UChar)(0x30 + (hour%100)/10));
+        id.append((UChar)(0x30 + (hour%10)));
+        id.append((UChar)0x3A);    // ':'
+        id.append((UChar)(0x30 + (min%100)/10));
+        id.append((UChar)(0x30 + (min%10)));

         if (sec != 0) {
         if (sec != 0) {

-            id.append(0x3A);    // ':'
-            id.append(0x30 + (sec%100)/10);
-            id.append(0x30 + (sec%10));
+          id.append((UChar)0x3A);    // ':'
+          id.append((UChar)(0x30 + (sec%100)/10));
+          id.append((UChar)(0x30 + (sec%10)));

         }
     }
     return id;
 }
 
         }
     }
     return id;
 }
 

+const UChar*
+ZoneMeta::getShortID(const TimeZone& tz) {
+    const UChar* canonicalID = NULL;
+    if (dynamic_cast<const OlsonTimeZone *>(&tz) != NULL) {
+        // short cut for OlsonTimeZone
+        const OlsonTimeZone *otz = (const OlsonTimeZone*)&tz;
+        canonicalID = otz->getCanonicalID();
+    }
+    if (canonicalID == NULL) {
+        return NULL;
+    }
+    return getShortIDFromCanonical(canonicalID);
+}
+
+const UChar*
+ZoneMeta::getShortID(const UnicodeString& id) {
+    UErrorCode status = U_ZERO_ERROR;
+    const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(id, status);
+    if (U_FAILURE(status) || canonicalID == NULL) {
+        return NULL;
+    }
+    return ZoneMeta::getShortIDFromCanonical(canonicalID);
+}
+
+const UChar*
+ZoneMeta::getShortIDFromCanonical(const UChar* canonicalID) {
+    const UChar* shortID = NULL;
+    int32_t len = u_strlen(canonicalID);
+    char tzidKey[ZID_KEY_MAX + 1];
+
+    u_UCharsToChars(canonicalID, tzidKey, len);
+    tzidKey[len] = (char) 0; // Make sure it is null terminated.
+
+    // replace '/' with ':'
+    char *p = tzidKey;
+    while (*p++) {
+        if (*p == '/') {
+            *p = ':';
+        }
+    }
+
+    UErrorCode status = U_ZERO_ERROR;
+    UResourceBundle *rb = ures_openDirect(NULL, gKeyTypeData, &status);
+    ures_getByKey(rb, gTypeMapTag, rb, &status);
+    ures_getByKey(rb, gTimezoneTag, rb, &status);
+    shortID = ures_getStringByKey(rb, tzidKey, NULL, &status);
+    ures_close(rb);
+
+    return shortID;
+}

 
 U_NAMESPACE_END
 
 
 U_NAMESPACE_END