icuSources/i18n/zonemeta.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2007-2014, International Business Machines Corporation and
   4 * others. All Rights Reserved.
   5 *******************************************************************************
   6 */
   7
   8 #include "unicode/utypes.h"
   9
  10 #if !UCONFIG_NO_FORMATTING
  11
  12 #include "zonemeta.h"
  13
  14 #include "unicode/timezone.h"
  15 #include "unicode/ustring.h"
  16 #include "unicode/putil.h"
  17 #include "unicode/simpletz.h"
  18
  19 #include "umutex.h"
  20 #include "uvector.h"
  21 #include "cmemory.h"
  22 #include "gregoimp.h"
  23 #include "cstring.h"
  24 #include "ucln_in.h"
  25 #include "uassert.h"
  26 #include "uresimp.h"
  27 #include "uhash.h"
  28 #include "olsontz.h"
  29
  30 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
  31
  32 static UMutex gZoneMetaLock = U_MUTEX_INITIALIZER;
  33
  34 // CLDR Canonical ID mapping table
  35 static UHashtable *gCanonicalIDCache = NULL;
  36 static icu::UInitOnce gCanonicalIDCacheInitOnce = U_INITONCE_INITIALIZER;
  37
  38 // Metazone mapping table
  39 static UHashtable *gOlsonToMeta = NULL;
  40 static icu::UInitOnce gOlsonToMetaInitOnce = U_INITONCE_INITIALIZER;
  41
  42 // Available metazone IDs vector and table
  43 static icu::UVector *gMetaZoneIDs = NULL;
  44 static UHashtable *gMetaZoneIDTable = NULL;
  45 static icu::UInitOnce gMetaZoneIDsInitOnce = U_INITONCE_INITIALIZER;
  46
  47 // Country info vectors
  48 static icu::UVector *gSingleZoneCountries = NULL;
  49 static icu::UVector *gMultiZonesCountries = NULL;
  50 static icu::UInitOnce gCountryInfoVectorsInitOnce = U_INITONCE_INITIALIZER;
  51
  52 U_CDECL_BEGIN
  53
  54 /**
  55  * Cleanup callback func
  56  */
  57 static UBool U_CALLCONV zoneMeta_cleanup(void)
  58 {
  59     if (gCanonicalIDCache != NULL) {
  60         uhash_close(gCanonicalIDCache);
  61         gCanonicalIDCache = NULL;
  62     }
  63     gCanonicalIDCacheInitOnce.reset();
  64
  65     if (gOlsonToMeta != NULL) {
  66         uhash_close(gOlsonToMeta);
  67         gOlsonToMeta = NULL;
  68     }
  69     gOlsonToMetaInitOnce.reset();
  70
  71     if (gMetaZoneIDTable != NULL) {
  72         uhash_close(gMetaZoneIDTable);
  73         gMetaZoneIDTable = NULL;
  74     }
  75     // delete after closing gMetaZoneIDTable, because it holds
  76     // value objects held by the hashtable
  77     delete gMetaZoneIDs;
  78     gMetaZoneIDs = NULL;
  79     gMetaZoneIDsInitOnce.reset();
  80
  81     delete gSingleZoneCountries;
  82     gSingleZoneCountries = NULL;
  83     delete gMultiZonesCountries;
  84     gMultiZonesCountries = NULL;
  85     gCountryInfoVectorsInitOnce.reset();
  86
  87     return TRUE;
  88 }
  89
  90 /**
  91  * Deleter for UChar* string
  92  */
  93 static void U_CALLCONV
  94 deleteUCharString(void *obj) {
  95     UChar *entry = (UChar*)obj;
  96     uprv_free(entry);
  97 }
  98
  99 /**
 100  * Deleter for UVector
 101  */
 102 static void U_CALLCONV
 103 deleteUVector(void *obj) {
 104    delete (icu::UVector*) obj;
 105 }
 106
 107 /**
 108  * Deleter for OlsonToMetaMappingEntry
 109  */
 110 static void U_CALLCONV
 111 deleteOlsonToMetaMappingEntry(void *obj) {
 112     icu::OlsonToMetaMappingEntry *entry = (icu::OlsonToMetaMappingEntry*)obj;
 113     uprv_free(entry);
 114 }
 115
 116 U_CDECL_END
 117
 118 U_NAMESPACE_BEGIN
 119
 120 #define ZID_KEY_MAX 128
 121
 122 static const char gMetaZones[]          = "metaZones";
 123 static const char gMetazoneInfo[]       = "metazoneInfo";
 124 static const char gMapTimezonesTag[]    = "mapTimezones";
 125
 126 static const char gKeyTypeData[]        = "keyTypeData";
 127 static const char gTypeAliasTag[]       = "typeAlias";
 128 static const char gTypeMapTag[]         = "typeMap";
 129 static const char gTimezoneTag[]        = "timezone";
 130
 131 static const char gPrimaryZonesTag[]    = "primaryZones";
 132
 133 static const char gWorldTag[]           = "001";
 134
 135 static const UChar gWorld[] = {0x30, 0x30, 0x31, 0x00}; // "001"
 136
 137 static const UChar gDefaultFrom[] = {0x31, 0x39, 0x37, 0x30, 0x2D, 0x30, 0x31, 0x2D, 0x30, 0x31,
 138                                      0x20, 0x30, 0x30, 0x3A, 0x30, 0x30, 0x00}; // "1970-01-01 00:00"
 139 static const UChar gDefaultTo[]   = {0x39, 0x39, 0x39, 0x39, 0x2D, 0x31, 0x32, 0x2D, 0x33, 0x31,
 140                                      0x20, 0x32, 0x33, 0x3A, 0x35, 0x39, 0x00}; // "9999-12-31 23:59"
 141
 142 static const UChar gCustomTzPrefix[]    = {0x47, 0x4D, 0x54, 0};    // "GMT"
 143
 144 #define ASCII_DIGIT(c) (((c)>=0x30 && (c)<=0x39) ? (c)-0x30 : -1)
 145
 146 /*
 147  * Convert a date string used by metazone mappings to UDate.
 148  * The format used by CLDR metazone mapping is "yyyy-MM-dd HH:mm".
 149  */
 150 static UDate
 151 parseDate (const UChar *text, UErrorCode &status) {
 152     if (U_FAILURE(status)) {
 153         return 0;
 154     }
 155     int32_t len = u_strlen(text);
 156     if (len != 16 && len != 10) {
 157         // It must be yyyy-MM-dd HH:mm (length 16) or yyyy-MM-dd (length 10)
 158         status = U_INVALID_FORMAT_ERROR;
 159         return 0;
 160     }
 161
 162     int32_t year = 0, month = 0, day = 0, hour = 0, min = 0, n;
 163     int32_t idx;
 164
 165     // "yyyy" (0 - 3)
 166     for (idx = 0; idx <= 3 && U_SUCCESS(status); idx++) {
 167         n = ASCII_DIGIT((int32_t)text[idx]);
 168         if (n >= 0) {
 169             year = 10*year + n;
 170         } else {
 171             status = U_INVALID_FORMAT_ERROR;
 172         }
 173     }
 174     // "MM" (5 - 6)
 175     for (idx = 5; idx <= 6 && U_SUCCESS(status); idx++) {
 176         n = ASCII_DIGIT((int32_t)text[idx]);
 177         if (n >= 0) {
 178             month = 10*month + n;
 179         } else {
 180             status = U_INVALID_FORMAT_ERROR;
 181         }
 182     }
 183     // "dd" (8 - 9)
 184     for (idx = 8; idx <= 9 && U_SUCCESS(status); idx++) {
 185         n = ASCII_DIGIT((int32_t)text[idx]);
 186         if (n >= 0) {
 187             day = 10*day + n;
 188         } else {
 189             status = U_INVALID_FORMAT_ERROR;
 190         }
 191     }
 192     if (len == 16) {
 193         // "HH" (11 - 12)
 194         for (idx = 11; idx <= 12 && U_SUCCESS(status); idx++) {
 195             n = ASCII_DIGIT((int32_t)text[idx]);
 196             if (n >= 0) {
 197                 hour = 10*hour + n;
 198             } else {
 199                 status = U_INVALID_FORMAT_ERROR;
 200             }
 201         }
 202         // "mm" (14 - 15)
 203         for (idx = 14; idx <= 15 && U_SUCCESS(status); idx++) {
 204             n = ASCII_DIGIT((int32_t)text[idx]);
 205             if (n >= 0) {
 206                 min = 10*min + n;
 207             } else {
 208                 status = U_INVALID_FORMAT_ERROR;
 209             }
 210         }
 211     }
 212
 213     if (U_SUCCESS(status)) {
 214         UDate date = Grego::fieldsToDay(year, month - 1, day) * U_MILLIS_PER_DAY
 215             + hour * U_MILLIS_PER_HOUR + min * U_MILLIS_PER_MINUTE;
 216         return date;
 217     }
 218     return 0;
 219 }
 220
 221 static void U_CALLCONV initCanonicalIDCache(UErrorCode &status) {
 222     gCanonicalIDCache = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status);
 223     if (gCanonicalIDCache == NULL) {
 224         status = U_MEMORY_ALLOCATION_ERROR;
 225     }
 226     if (U_FAILURE(status)) {
 227         gCanonicalIDCache = NULL;
 228     }
 229     // No key/value deleters - keys/values are from a resource bundle
 230     ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);
 231 }
 232
 233
 234 const UChar* U_EXPORT2
 235 ZoneMeta::getCanonicalCLDRID(const UnicodeString &tzid, UErrorCode& status) {
 236     if (U_FAILURE(status)) {
 237         return NULL;
 238     }
 239
 240     if (tzid.isBogus() || tzid.length() > ZID_KEY_MAX) {
 241         status = U_ILLEGAL_ARGUMENT_ERROR;
 242         return NULL;
 243     }
 244
 245     // Checking the cached results
 246     umtx_initOnce(gCanonicalIDCacheInitOnce, &initCanonicalIDCache, status);
 247     if (U_FAILURE(status)) {
 248         return NULL;
 249     }
 250
 251     const UChar *canonicalID = NULL;
 252
 253     UErrorCode tmpStatus = U_ZERO_ERROR;
 254     UChar utzid[ZID_KEY_MAX + 1];
 255     tzid.extract(utzid, ZID_KEY_MAX + 1, tmpStatus);
 256     U_ASSERT(tmpStatus == U_ZERO_ERROR);    // we checked the length of tzid already
 257
 258     // Check if it was already cached
 259     umtx_lock(&gZoneMetaLock);
 260     {
 261         canonicalID = (const UChar *)uhash_get(gCanonicalIDCache, utzid);
 262     }
 263     umtx_unlock(&gZoneMetaLock);
 264
 265     if (canonicalID != NULL) {
 266         return canonicalID;
 267     }
 268
 269     // If not, resolve CLDR canonical ID with resource data
 270     UBool isInputCanonical = FALSE;
 271     char id[ZID_KEY_MAX + 1];
 272     tzid.extract(0, 0x7fffffff, id, LENGTHOF(id), US_INV);
 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, gKeyTypeData, &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                 int32_t 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
 370 UnicodeString& U_EXPORT2
 371 ZoneMeta::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
 381 const UChar* U_EXPORT2
 382 ZoneMeta::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 static void U_CALLCONV countryInfoVectorsInit(UErrorCode &status) {
 394     // Create empty vectors
 395     // No deleters for these UVectors, it's a reference to a resource bundle string.
 396     gSingleZoneCountries = new UVector(NULL, uhash_compareUChars, status);
 397     if (gSingleZoneCountries == NULL) {
 398         status = U_MEMORY_ALLOCATION_ERROR;
 399     }
 400     gMultiZonesCountries = new UVector(NULL, uhash_compareUChars, status);
 401     if (gMultiZonesCountries == NULL) {
 402         status = U_MEMORY_ALLOCATION_ERROR;
 403     }
 404
 405     if (U_FAILURE(status)) {
 406         delete gSingleZoneCountries;
 407         delete gMultiZonesCountries;
 408         gSingleZoneCountries = NULL;
 409         gMultiZonesCountries  = NULL;
 410     }
 411     ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);
 412 }
 413
 414
 415 UnicodeString& U_EXPORT2
 416 ZoneMeta::getCanonicalCountry(const UnicodeString &tzid, UnicodeString &country, UBool *isPrimary /* = NULL */) {
 417     if (isPrimary != NULL) {
 418         *isPrimary = FALSE;
 419     }
 420
 421     const UChar *region = TimeZone::getRegion(tzid);
 422     if (region != NULL && u_strcmp(gWorld, region) != 0) {
 423         country.setTo(region, -1);
 424     } else {
 425         country.setToBogus();
 426         return country;
 427     }
 428
 429     if (isPrimary != NULL) {
 430         char regionBuf[] = {0, 0, 0};
 431
 432         // Checking the cached results
 433         UErrorCode status = U_ZERO_ERROR;
 434         umtx_initOnce(gCountryInfoVectorsInitOnce, &countryInfoVectorsInit, status);
 435         if (U_FAILURE(status)) {
 436             return country;
 437         }
 438
 439         // Check if it was already cached
 440         UBool cached = FALSE;
 441         UBool singleZone = FALSE;
 442         umtx_lock(&gZoneMetaLock);
 443         {
 444             singleZone = cached = gSingleZoneCountries->contains((void*)region);
 445             if (!cached) {
 446                 cached = gMultiZonesCountries->contains((void*)region);
 447             }
 448         }
 449         umtx_unlock(&gZoneMetaLock);
 450
 451         if (!cached) {
 452             // We need to go through all zones associated with the region.
 453             // This is relatively heavy operation.
 454
 455             U_ASSERT(u_strlen(region) == 2);
 456
 457             u_UCharsToChars(region, regionBuf, 2);
 458
 459             StringEnumeration *ids = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL_LOCATION, regionBuf, NULL, status);
 460             int32_t idsLen = ids->count(status);
 461             if (U_SUCCESS(status) && idsLen == 1) {
 462                 // only the single zone is available for the region
 463                 singleZone = TRUE;
 464             }
 465             delete ids;
 466
 467             // Cache the result
 468             umtx_lock(&gZoneMetaLock);
 469             {
 470                 UErrorCode ec = U_ZERO_ERROR;
 471                 if (singleZone) {
 472                     if (!gSingleZoneCountries->contains((void*)region)) {
 473                         gSingleZoneCountries->addElement((void*)region, ec);
 474                     }
 475                 } else {
 476                     if (!gMultiZonesCountries->contains((void*)region)) {
 477                         gMultiZonesCountries->addElement((void*)region, ec);
 478                     }
 479                 }
 480             }
 481             umtx_unlock(&gZoneMetaLock);
 482         }
 483
 484         if (singleZone) {
 485             *isPrimary = TRUE;
 486         } else {
 487             // Note: We may cache the primary zone map in future.
 488
 489             // Even a country has multiple zones, one of them might be
 490             // dominant and treated as a primary zone
 491             int32_t idLen = 0;
 492             if (regionBuf[0] == 0) {
 493                 u_UCharsToChars(region, regionBuf, 2);
 494             }
 495
 496             UResourceBundle *rb = ures_openDirect(NULL, gMetaZones, &status);
 497             ures_getByKey(rb, gPrimaryZonesTag, rb, &status);
 498             const UChar *primaryZone = ures_getStringByKey(rb, regionBuf, &idLen, &status);
 499             if (U_SUCCESS(status)) {
 500                 if (tzid.compare(primaryZone, idLen) == 0) {
 501                     *isPrimary = TRUE;
 502                 } else {
 503                     // The given ID might not be a canonical ID
 504                     UnicodeString canonicalID;
 505                     TimeZone::getCanonicalID(tzid, canonicalID, status);
 506                     if (U_SUCCESS(status) && canonicalID.compare(primaryZone, idLen) == 0) {
 507                         *isPrimary = TRUE;
 508                     }
 509                 }
 510             }
 511             ures_close(rb);
 512         }
 513     }
 514
 515     return country;
 516 }
 517
 518 UnicodeString& U_EXPORT2
 519 ZoneMeta::getMetazoneID(const UnicodeString &tzid, UDate date, UnicodeString &result) {
 520     UBool isSet = FALSE;
 521     const UVector *mappings = getMetazoneMappings(tzid);
 522     if (mappings != NULL) {
 523         for (int32_t i = 0; i < mappings->size(); i++) {
 524             OlsonToMetaMappingEntry *mzm = (OlsonToMetaMappingEntry*)mappings->elementAt(i);
 525             if (mzm->from <= date && mzm->to > date) {
 526                 result.setTo(mzm->mzid, -1);
 527                 isSet = TRUE;
 528                 break;
 529             }
 530         }
 531     }
 532     if (!isSet) {
 533         result.setToBogus();
 534     }
 535     return result;
 536 }
 537
 538 static void U_CALLCONV olsonToMetaInit(UErrorCode &status) {
 539     U_ASSERT(gOlsonToMeta == NULL);
 540     ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);
 541     gOlsonToMeta = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status);
 542     if (U_FAILURE(status)) {
 543         gOlsonToMeta = NULL;
 544     } else {
 545         uhash_setKeyDeleter(gOlsonToMeta, deleteUCharString);
 546         uhash_setValueDeleter(gOlsonToMeta, deleteUVector);
 547     }
 548 }
 549
 550
 551 const UVector* U_EXPORT2
 552 ZoneMeta::getMetazoneMappings(const UnicodeString &tzid) {
 553     UErrorCode status = U_ZERO_ERROR;
 554     UChar tzidUChars[ZID_KEY_MAX + 1];
 555     tzid.extract(tzidUChars, ZID_KEY_MAX + 1, status);
 556     if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING) {
 557         return NULL;
 558     }
 559
 560     umtx_initOnce(gOlsonToMetaInitOnce, &olsonToMetaInit, status);
 561     if (U_FAILURE(status)) {
 562         return NULL;
 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
 619 UVector*
 620 ZoneMeta::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
 710 UnicodeString& U_EXPORT2
 711 ZoneMeta::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.isBogus() || 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
 756 static void U_CALLCONV initAvailableMetaZoneIDs () {
 757     U_ASSERT(gMetaZoneIDs == NULL);
 758     U_ASSERT(gMetaZoneIDTable == NULL);
 759     ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);
 760
 761     UErrorCode status = U_ZERO_ERROR;
 762     gMetaZoneIDTable = uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, NULL, &status);
 763     if (U_FAILURE(status) || gMetaZoneIDTable == NULL) {
 764         gMetaZoneIDTable = NULL;
 765         return;
 766     }
 767     uhash_setKeyDeleter(gMetaZoneIDTable, uprv_deleteUObject);
 768     // No valueDeleter, because the vector maintain the value objects
 769     gMetaZoneIDs = new UVector(NULL, uhash_compareUChars, status);
 770     if (U_FAILURE(status) || gMetaZoneIDs == NULL) {
 771         gMetaZoneIDs = NULL;
 772         uhash_close(gMetaZoneIDTable);
 773         gMetaZoneIDTable = NULL;
 774         return;
 775     }
 776     gMetaZoneIDs->setDeleter(uprv_free);
 777
 778     UResourceBundle *rb = ures_openDirect(NULL, gMetaZones, &status);
 779     UResourceBundle *bundle = ures_getByKey(rb, gMapTimezonesTag, NULL, &status);
 780     UResourceBundle res;
 781     ures_initStackObject(&res);
 782     while (U_SUCCESS(status) && ures_hasNext(bundle)) {
 783         ures_getNextResource(bundle, &res, &status);
 784         if (U_FAILURE(status)) {
 785             break;
 786         }
 787         const char *mzID = ures_getKey(&res);
 788         int32_t len = uprv_strlen(mzID);
 789         UChar *uMzID = (UChar*)uprv_malloc(sizeof(UChar) * (len + 1));
 790         if (uMzID == NULL) {
 791             status = U_MEMORY_ALLOCATION_ERROR;
 792             break;
 793         }
 794         u_charsToUChars(mzID, uMzID, len);
 795         uMzID[len] = 0;
 796         UnicodeString *usMzID = new UnicodeString(uMzID);
 797         if (uhash_get(gMetaZoneIDTable, usMzID) == NULL) {
 798             gMetaZoneIDs->addElement((void *)uMzID, status);
 799             uhash_put(gMetaZoneIDTable, (void *)usMzID, (void *)uMzID, &status);
 800         } else {
 801             uprv_free(uMzID);
 802             delete usMzID;
 803         }
 804     }
 805     ures_close(&res);
 806     ures_close(bundle);
 807     ures_close(rb);
 808
 809     if (U_FAILURE(status)) {
 810         uhash_close(gMetaZoneIDTable);
 811         delete gMetaZoneIDs;
 812         gMetaZoneIDTable = NULL;
 813         gMetaZoneIDs = NULL;
 814     }
 815 }
 816
 817 const UVector*
 818 ZoneMeta::getAvailableMetazoneIDs() {
 819     umtx_initOnce(gMetaZoneIDsInitOnce, &initAvailableMetaZoneIDs);
 820     return gMetaZoneIDs;
 821 }
 822
 823 const UChar*
 824 ZoneMeta::findMetaZoneID(const UnicodeString& mzid) {
 825     umtx_initOnce(gMetaZoneIDsInitOnce, &initAvailableMetaZoneIDs);
 826     if (gMetaZoneIDTable == NULL) {
 827         return NULL;
 828     }
 829     return (const UChar*)uhash_get(gMetaZoneIDTable, &mzid);
 830 }
 831
 832 const UChar*
 833 ZoneMeta::findTimeZoneID(const UnicodeString& tzid) {
 834     return TimeZone::findID(tzid);
 835 }
 836
 837
 838 TimeZone*
 839 ZoneMeta::createCustomTimeZone(int32_t offset) {
 840     UBool negative = FALSE;
 841     int32_t tmp = offset;
 842     if (offset < 0) {
 843         negative = TRUE;
 844         tmp = -offset;
 845     }
 846     int32_t hour, min, sec;
 847
 848     tmp /= 1000;
 849     sec = tmp % 60;
 850     tmp /= 60;
 851     min = tmp % 60;
 852     hour = tmp / 60;
 853
 854     UnicodeString zid;
 855     formatCustomID(hour, min, sec, negative, zid);
 856     return new SimpleTimeZone(offset, zid);
 857 }
 858
 859 UnicodeString&
 860 ZoneMeta::formatCustomID(uint8_t hour, uint8_t min, uint8_t sec, UBool negative, UnicodeString& id) {
 861     // Create normalized time zone ID - GMT[+|-]HH:mm[:ss]
 862     id.setTo(gCustomTzPrefix, -1);
 863     if (hour != 0 || min != 0) {
 864         if (negative) {
 865           id.append((UChar)0x2D);    // '-'
 866         } else {
 867           id.append((UChar)0x2B);    // '+'
 868         }
 869         // Always use US-ASCII digits
 870         id.append((UChar)(0x30 + (hour%100)/10));
 871         id.append((UChar)(0x30 + (hour%10)));
 872         id.append((UChar)0x3A);    // ':'
 873         id.append((UChar)(0x30 + (min%100)/10));
 874         id.append((UChar)(0x30 + (min%10)));
 875         if (sec != 0) {
 876           id.append((UChar)0x3A);    // ':'
 877           id.append((UChar)(0x30 + (sec%100)/10));
 878           id.append((UChar)(0x30 + (sec%10)));
 879         }
 880     }
 881     return id;
 882 }
 883
 884 const UChar*
 885 ZoneMeta::getShortID(const TimeZone& tz) {
 886     const UChar* canonicalID = NULL;
 887     if (dynamic_cast<const OlsonTimeZone *>(&tz) != NULL) {
 888         // short cut for OlsonTimeZone
 889         const OlsonTimeZone *otz = (const OlsonTimeZone*)&tz;
 890         canonicalID = otz->getCanonicalID();
 891     }
 892     if (canonicalID == NULL) {
 893         return NULL;
 894     }
 895     return getShortIDFromCanonical(canonicalID);
 896 }
 897
 898 const UChar*
 899 ZoneMeta::getShortID(const UnicodeString& id) {
 900     UErrorCode status = U_ZERO_ERROR;
 901     const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(id, status);
 902     if (U_FAILURE(status) || canonicalID == NULL) {
 903         return NULL;
 904     }
 905     return ZoneMeta::getShortIDFromCanonical(canonicalID);
 906 }
 907
 908 const UChar*
 909 ZoneMeta::getShortIDFromCanonical(const UChar* canonicalID) {
 910     const UChar* shortID = NULL;
 911     int32_t len = u_strlen(canonicalID);
 912     char tzidKey[ZID_KEY_MAX + 1];
 913
 914     u_UCharsToChars(canonicalID, tzidKey, len);
 915     tzidKey[len] = (char) 0; // Make sure it is null terminated.
 916
 917     // replace '/' with ':'
 918     char *p = tzidKey;
 919     while (*p++) {
 920         if (*p == '/') {
 921             *p = ':';
 922         }
 923     }
 924
 925     UErrorCode status = U_ZERO_ERROR;
 926     UResourceBundle *rb = ures_openDirect(NULL, gKeyTypeData, &status);
 927     ures_getByKey(rb, gTypeMapTag, rb, &status);
 928     ures_getByKey(rb, gTimezoneTag, rb, &status);
 929     shortID = ures_getStringByKey(rb, tzidKey, NULL, &status);
 930     ures_close(rb);
 931
 932     return shortID;
 933 }
 934
 935 U_NAMESPACE_END
 936
 937 #endif /* #if !UCONFIG_NO_FORMATTING */