icuSources/i18n/zonemeta.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2007-2010, 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
  26 static UMTX gZoneMetaLock = NULL;
  27
  28 // Metazone mapping table
  29 static UHashtable *gOlsonToMeta = NULL;
  30 static UBool gOlsonToMetaInitialized = FALSE;
  31
  32 // Country info vectors
  33 static U_NAMESPACE_QUALIFIER UVector *gSingleZoneCountries = NULL;
  34 static U_NAMESPACE_QUALIFIER UVector *gMultiZonesCountries = NULL;
  35 static UBool gCountryInfoVectorsInitialized = FALSE;
  36
  37 U_CDECL_BEGIN
  38
  39
  40 /**
  41  * Cleanup callback func
  42  */
  43 static UBool U_CALLCONV zoneMeta_cleanup(void)
  44 {
  45      umtx_destroy(&gZoneMetaLock);
  46
  47     if (gOlsonToMeta != NULL) {
  48         uhash_close(gOlsonToMeta);
  49         gOlsonToMeta = NULL;
  50     }
  51     gOlsonToMetaInitialized = FALSE;
  52
  53     delete gSingleZoneCountries;
  54     delete gMultiZonesCountries;
  55     gCountryInfoVectorsInitialized = FALSE;
  56
  57     return TRUE;
  58 }
  59
  60 /**
  61  * Deleter for UChar* string
  62  */
  63 static void U_CALLCONV
  64 deleteUCharString(void *obj) {
  65     UChar *entry = (UChar*)obj;
  66     uprv_free(entry);
  67 }
  68
  69 /**
  70  * Deleter for UVector
  71  */
  72 static void U_CALLCONV
  73 deleteUVector(void *obj) {
  74    delete (U_NAMESPACE_QUALIFIER UVector*) obj;
  75 }
  76
  77 /**
  78  * Deleter for OlsonToMetaMappingEntry
  79  */
  80 static void U_CALLCONV
  81 deleteOlsonToMetaMappingEntry(void *obj) {
  82     U_NAMESPACE_QUALIFIER OlsonToMetaMappingEntry *entry = (U_NAMESPACE_QUALIFIER OlsonToMetaMappingEntry*)obj;
  83     uprv_free(entry);
  84 }
  85
  86 U_CDECL_END
  87
  88 U_NAMESPACE_BEGIN
  89
  90 #define ZID_KEY_MAX 128
  91
  92 static const char gMetaZones[]          = "metaZones";
  93 static const char gMetazoneInfo[]       = "metazoneInfo";
  94 static const char gMapTimezonesTag[]    = "mapTimezones";
  95
  96 static const char gTimeZoneTypes[]      = "timezoneTypes";
  97 static const char gTypeAliasTag[]       = "typeAlias";
  98 static const char gTypeMapTag[]         = "typeMap";
  99 static const char gTimezoneTag[]        = "timezone";
 100
 101 static const char gWorldTag[]           = "001";
 102
 103 static const UChar gWorld[] = {0x30, 0x30, 0x31, 0x00}; // "001"
 104
 105 static const UChar gDefaultFrom[] = {0x31, 0x39, 0x37, 0x30, 0x2D, 0x30, 0x31, 0x2D, 0x30, 0x31,
 106                                      0x20, 0x30, 0x30, 0x3A, 0x30, 0x30, 0x00}; // "1970-01-01 00:00"
 107 static const UChar gDefaultTo[]   = {0x39, 0x39, 0x39, 0x39, 0x2D, 0x31, 0x32, 0x2D, 0x33, 0x31,
 108                                      0x20, 0x32, 0x33, 0x3A, 0x35, 0x39, 0x00}; // "9999-12-31 23:59"
 109
 110 #define ASCII_DIGIT(c) (((c)>=0x30 && (c)<=0x39) ? (c)-0x30 : -1)
 111
 112 /*
 113  * Convert a date string used by metazone mappings to UDate.
 114  * The format used by CLDR metazone mapping is "yyyy-MM-dd HH:mm".
 115  */
 116 static UDate
 117 parseDate (const UChar *text, UErrorCode &status) {
 118     if (U_FAILURE(status)) {
 119         return 0;
 120     }
 121     int32_t len = u_strlen(text);
 122     if (len != 16 && len != 10) {
 123         // It must be yyyy-MM-dd HH:mm (length 16) or yyyy-MM-dd (length 10)
 124         status = U_INVALID_FORMAT_ERROR;
 125         return 0;
 126     }
 127
 128     int32_t year = 0, month = 0, day = 0, hour = 0, min = 0, n;
 129     int32_t idx;
 130
 131     // "yyyy" (0 - 3)
 132     for (idx = 0; idx <= 3 && U_SUCCESS(status); idx++) {
 133         n = ASCII_DIGIT((int32_t)text[idx]);
 134         if (n >= 0) {
 135             year = 10*year + n;
 136         } else {
 137             status = U_INVALID_FORMAT_ERROR;
 138         }
 139     }
 140     // "MM" (5 - 6)
 141     for (idx = 5; idx <= 6 && U_SUCCESS(status); idx++) {
 142         n = ASCII_DIGIT((int32_t)text[idx]);
 143         if (n >= 0) {
 144             month = 10*month + n;
 145         } else {
 146             status = U_INVALID_FORMAT_ERROR;
 147         }
 148     }
 149     // "dd" (8 - 9)
 150     for (idx = 8; idx <= 9 && U_SUCCESS(status); idx++) {
 151         n = ASCII_DIGIT((int32_t)text[idx]);
 152         if (n >= 0) {
 153             day = 10*day + n;
 154         } else {
 155             status = U_INVALID_FORMAT_ERROR;
 156         }
 157     }
 158     if (len == 16) {
 159         // "HH" (11 - 12)
 160         for (idx = 11; idx <= 12 && U_SUCCESS(status); idx++) {
 161             n = ASCII_DIGIT((int32_t)text[idx]);
 162             if (n >= 0) {
 163                 hour = 10*hour + n;
 164             } else {
 165                 status = U_INVALID_FORMAT_ERROR;
 166             }
 167         }
 168         // "mm" (14 - 15)
 169         for (idx = 14; idx <= 15 && U_SUCCESS(status); idx++) {
 170             n = ASCII_DIGIT((int32_t)text[idx]);
 171             if (n >= 0) {
 172                 min = 10*min + n;
 173             } else {
 174                 status = U_INVALID_FORMAT_ERROR;
 175             }
 176         }
 177     }
 178
 179     if (U_SUCCESS(status)) {
 180         UDate date = Grego::fieldsToDay(year, month - 1, day) * U_MILLIS_PER_DAY
 181             + hour * U_MILLIS_PER_HOUR + min * U_MILLIS_PER_MINUTE;
 182         return date;
 183     }
 184     return 0;
 185 }
 186
 187 UnicodeString& U_EXPORT2
 188 ZoneMeta::getCanonicalSystemID(const UnicodeString &tzid, UnicodeString &systemID, UErrorCode& status) {
 189     int32_t len = tzid.length();
 190     if ( len >= ZID_KEY_MAX ) {
 191         status = U_ILLEGAL_ARGUMENT_ERROR;
 192         systemID.remove();
 193         return systemID;
 194     }
 195
 196     char id[ZID_KEY_MAX];
 197     const UChar* idChars = tzid.getBuffer();
 198
 199     u_UCharsToChars(idChars,id,len);
 200     id[len] = (char) 0; // Make sure it is null terminated.
 201
 202     // replace '/' with ':'
 203     char *p = id;
 204     while (*p++) {
 205         if (*p == '/') {
 206             *p = ':';
 207         }
 208     }
 209
 210
 211     UErrorCode tmpStatus = U_ZERO_ERROR;
 212     UResourceBundle *top = ures_openDirect(NULL, gTimeZoneTypes, &tmpStatus);
 213     UResourceBundle *rb = ures_getByKey(top, gTypeMapTag, NULL, &tmpStatus);
 214     ures_getByKey(rb, gTimezoneTag, rb, &tmpStatus);
 215     ures_getByKey(rb, id, rb, &tmpStatus);
 216     if (U_SUCCESS(tmpStatus)) {
 217         // direct map found
 218         systemID.setTo(tzid);
 219         ures_close(rb);
 220         ures_close(top);
 221         return systemID;
 222     }
 223
 224     // If a map element not found, then look for an alias
 225     tmpStatus = U_ZERO_ERROR;
 226     ures_getByKey(top, gTypeAliasTag, rb, &tmpStatus);
 227     ures_getByKey(rb, gTimezoneTag, rb, &tmpStatus);
 228     const UChar *alias = ures_getStringByKey(rb,id,NULL,&tmpStatus);
 229     if (U_SUCCESS(tmpStatus)) {
 230         // alias found
 231         ures_close(rb);
 232         ures_close(top);
 233         systemID.setTo(alias);
 234         return systemID;
 235     }
 236
 237     // Dereference the input ID using the tz data
 238     const UChar *derefer = TimeZone::dereferOlsonLink(tzid);
 239     if (derefer == NULL) {
 240         systemID.remove();
 241         status = U_ILLEGAL_ARGUMENT_ERROR;
 242     } else {
 243
 244         len = u_strlen(derefer);
 245         u_UCharsToChars(derefer,id,len);
 246         id[len] = (char) 0; // Make sure it is null terminated.
 247
 248         // replace '/' with ':'
 249         char *p = id;
 250         while (*p++) {
 251             if (*p == '/') {
 252                 *p = ':';
 253             }
 254         }
 255
 256         // If a dereference turned something up then look for an alias.
 257         // rb still points to the alias table, so we don't have to go looking
 258         // for it.
 259         tmpStatus = U_ZERO_ERROR;
 260         const UChar *alias = ures_getStringByKey(rb,id,NULL,&tmpStatus);
 261         if (U_SUCCESS(tmpStatus)) {
 262             // alias found
 263             systemID.setTo(alias);
 264         } else {
 265             systemID.setTo(derefer);
 266         }
 267     }
 268
 269      ures_close(rb);
 270      ures_close(top);
 271      return systemID;
 272 }
 273
 274 UnicodeString& U_EXPORT2
 275 ZoneMeta::getCanonicalCountry(const UnicodeString &tzid, UnicodeString &canonicalCountry) {
 276     const UChar *region = TimeZone::getRegion(tzid);
 277     if (u_strcmp(gWorld, region) != 0) {
 278         canonicalCountry.setTo(region, -1);
 279     } else {
 280         canonicalCountry.remove();
 281     }
 282     return canonicalCountry;
 283 }
 284
 285 UnicodeString& U_EXPORT2
 286 ZoneMeta::getSingleCountry(const UnicodeString &tzid, UnicodeString &country) {
 287     // Get canonical country for the zone
 288     const UChar *region = TimeZone::getRegion(tzid);
 289     if (u_strcmp(gWorld, region) == 0) {
 290         // special case - "001"
 291         country.remove();
 292         return country;
 293     }
 294
 295     // Checking the cached results
 296     UErrorCode status = U_ZERO_ERROR;
 297     UBool initialized;
 298     UMTX_CHECK(&gZoneMetaLock, gCountryInfoVectorsInitialized, initialized);
 299     if (!initialized) {
 300         // Create empty vectors
 301         umtx_lock(&gZoneMetaLock);
 302         {
 303             if (!gCountryInfoVectorsInitialized) {
 304                 // No deleters for these UVectors, it's a reference to a resource bundle string.
 305                 gSingleZoneCountries = new UVector(NULL, uhash_compareUChars, status);
 306                 if (gSingleZoneCountries == NULL) {
 307                     status = U_MEMORY_ALLOCATION_ERROR;
 308                 }
 309                 gMultiZonesCountries = new UVector(NULL, uhash_compareUChars, status);
 310                 if (gMultiZonesCountries == NULL) {
 311                     status = U_MEMORY_ALLOCATION_ERROR;
 312                 }
 313
 314                 if (U_SUCCESS(status)) {
 315                     gCountryInfoVectorsInitialized = TRUE;
 316                 } else {
 317                     delete gSingleZoneCountries;
 318                     delete gMultiZonesCountries;
 319                 }
 320             }
 321         }
 322         umtx_unlock(&gZoneMetaLock);
 323
 324         if (U_FAILURE(status)) {
 325             country.remove();
 326             return country;
 327         }
 328     }
 329
 330     // Check if it was already cached
 331     UBool cached = FALSE;
 332     UBool multiZones = FALSE;
 333     umtx_lock(&gZoneMetaLock);
 334     {
 335         multiZones = cached = gMultiZonesCountries->contains((void*)region);
 336         if (!multiZones) {
 337             cached = gSingleZoneCountries->contains((void*)region);
 338         }
 339     }
 340     umtx_unlock(&gZoneMetaLock);
 341
 342     if (!cached) {
 343         // We need to go through all zones associated with the region.
 344         // This is relatively heavy operation.
 345
 346         U_ASSERT(u_strlen(region) == 2);
 347
 348         char buf[] = {0, 0, 0};
 349         u_UCharsToChars(region, buf, 2);
 350
 351         StringEnumeration *ids = TimeZone::createEnumeration(buf);
 352         int32_t idsLen = ids->count(status);
 353         if (U_SUCCESS(status) && idsLen > 1) {
 354             // multiple zones are available for the region
 355             UnicodeString canonical, tmp;
 356             const UnicodeString *id = ids->snext(status);
 357             getCanonicalSystemID(*id, canonical, status);
 358             if (U_SUCCESS(status)) {
 359                 // check if there are any other canonical zone in the group
 360                 while ((id = ids->snext(status))!=NULL) {
 361                     getCanonicalSystemID(*id, tmp, status);
 362                     if (U_FAILURE(status)) {
 363                         break;
 364                     }
 365                     if (canonical != tmp) {
 366                         // another canonical zone was found
 367                         multiZones = TRUE;
 368                         break;
 369                     }
 370                 }
 371             }
 372         }
 373         if (U_FAILURE(status)) {
 374             // no single country by default for any error cases
 375             multiZones = TRUE;
 376         }
 377         delete ids;
 378
 379         // Cache the result
 380         umtx_lock(&gZoneMetaLock);
 381         {
 382             UErrorCode ec = U_ZERO_ERROR;
 383             if (multiZones) {
 384                 if (!gMultiZonesCountries->contains((void*)region)) {
 385                     gMultiZonesCountries->addElement((void*)region, ec);
 386                 }
 387             } else {
 388                 if (!gSingleZoneCountries->contains((void*)region)) {
 389                     gSingleZoneCountries->addElement((void*)region, ec);
 390                 }
 391             }
 392         }
 393         umtx_unlock(&gZoneMetaLock);
 394     }
 395
 396     if (multiZones) {
 397         country.remove();
 398     } else {
 399         country.setTo(region, -1);
 400     }
 401     return country;
 402 }
 403
 404 UnicodeString& U_EXPORT2
 405 ZoneMeta::getMetazoneID(const UnicodeString &tzid, UDate date, UnicodeString &result) {
 406     UBool isSet = FALSE;
 407     const UVector *mappings = getMetazoneMappings(tzid);
 408     if (mappings != NULL) {
 409         for (int32_t i = 0; i < mappings->size(); i++) {
 410             OlsonToMetaMappingEntry *mzm = (OlsonToMetaMappingEntry*)mappings->elementAt(i);
 411             if (mzm->from <= date && mzm->to > date) {
 412                 result.setTo(mzm->mzid, -1);
 413                 isSet = TRUE;
 414                 break;
 415             }
 416         }
 417     }
 418     if (!isSet) {
 419         result.remove();
 420     }
 421     return result;
 422 }
 423
 424 const UVector* U_EXPORT2
 425 ZoneMeta::getMetazoneMappings(const UnicodeString &tzid) {
 426     UErrorCode status = U_ZERO_ERROR;
 427     UChar tzidUChars[ZID_KEY_MAX];
 428     tzid.extract(tzidUChars, ZID_KEY_MAX, status);
 429     if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING) {
 430         return NULL;
 431     }
 432
 433     UBool initialized;
 434     UMTX_CHECK(&gZoneMetaLock, gOlsonToMetaInitialized, initialized);
 435     if (!initialized) {
 436         UHashtable *tmpOlsonToMeta = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status);
 437         if (U_FAILURE(status)) {
 438             return NULL;
 439         }
 440         uhash_setKeyDeleter(tmpOlsonToMeta, deleteUCharString);
 441         uhash_setValueDeleter(tmpOlsonToMeta, deleteUVector);
 442
 443         umtx_lock(&gZoneMetaLock);
 444         {
 445             if (!gOlsonToMetaInitialized) {
 446                 gOlsonToMeta = tmpOlsonToMeta;
 447                 tmpOlsonToMeta = NULL;
 448                 gOlsonToMetaInitialized = TRUE;
 449             }
 450         }
 451         umtx_unlock(&gZoneMetaLock);
 452
 453         // OK to call the following multiple times with the same function
 454         ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup);
 455         if (tmpOlsonToMeta != NULL) {
 456             uhash_close(tmpOlsonToMeta);
 457         }
 458     }
 459
 460     // get the mapping from cache
 461     const UVector *result = NULL;
 462
 463     umtx_lock(&gZoneMetaLock);
 464     {
 465         result = (UVector*) uhash_get(gOlsonToMeta, tzidUChars);
 466     }
 467     umtx_unlock(&gZoneMetaLock);
 468
 469     if (result != NULL) {
 470         return result;
 471     }
 472
 473     // miss the cache - create new one
 474     UVector *tmpResult = createMetazoneMappings(tzid);
 475     if (tmpResult == NULL) {
 476         // not available
 477         return NULL;
 478     }
 479
 480     // put the new one into the cache
 481     umtx_lock(&gZoneMetaLock);
 482     {
 483         // make sure it's already created
 484         result = (UVector*) uhash_get(gOlsonToMeta, tzidUChars);
 485         if (result == NULL) {
 486             // add the one just created
 487             int32_t tzidLen = tzid.length() + 1;
 488             UChar *key = (UChar*)uprv_malloc(tzidLen * sizeof(UChar));
 489             if (key == NULL) {
 490                 // memory allocation error..  just return NULL
 491                 result = NULL;
 492                 delete tmpResult;
 493             } else {
 494                 tzid.extract(key, tzidLen, status);
 495                 uhash_put(gOlsonToMeta, key, tmpResult, &status);
 496                 if (U_FAILURE(status)) {
 497                     // delete the mapping
 498                     result = NULL;
 499                     delete tmpResult;
 500                 } else {
 501                     result = tmpResult;
 502                 }
 503             }
 504         } else {
 505             // another thread already put the one
 506             delete tmpResult;
 507         }
 508     }
 509     umtx_unlock(&gZoneMetaLock);
 510
 511     return result;
 512 }
 513
 514 UVector*
 515 ZoneMeta::createMetazoneMappings(const UnicodeString &tzid) {
 516     UVector *mzMappings = NULL;
 517     UErrorCode status = U_ZERO_ERROR;
 518
 519     UnicodeString canonicalID;
 520     UResourceBundle *rb = ures_openDirect(NULL, gMetaZones, &status);
 521     ures_getByKey(rb, gMetazoneInfo, rb, &status);
 522     TimeZone::getCanonicalID(tzid, canonicalID, status);
 523
 524     if (U_SUCCESS(status)) {
 525         char tzKey[ZID_KEY_MAX];
 526         canonicalID.extract(0, canonicalID.length(), tzKey, sizeof(tzKey), US_INV);
 527
 528         // tzid keys are using ':' as separators
 529         char *p = tzKey;
 530         while (*p) {
 531             if (*p == '/') {
 532                 *p = ':';
 533             }
 534             p++;
 535         }
 536
 537         ures_getByKey(rb, tzKey, rb, &status);
 538
 539         if (U_SUCCESS(status)) {
 540             UResourceBundle *mz = NULL;
 541             while (ures_hasNext(rb)) {
 542                 mz = ures_getNextResource(rb, mz, &status);
 543
 544                 const UChar *mz_name = ures_getStringByIndex(mz, 0, NULL, &status);
 545                 const UChar *mz_from = gDefaultFrom;
 546                 const UChar *mz_to = gDefaultTo;
 547
 548                 if (ures_getSize(mz) == 3) {
 549                     mz_from = ures_getStringByIndex(mz, 1, NULL, &status);
 550                     mz_to   = ures_getStringByIndex(mz, 2, NULL, &status);
 551                 }
 552
 553                 if(U_FAILURE(status)){
 554                     status = U_ZERO_ERROR;
 555                     continue;
 556                 }
 557                 // We do not want to use SimpleDateformat to parse boundary dates,
 558                 // because this code could be triggered by the initialization code
 559                 // used by SimpleDateFormat.
 560                 UDate from = parseDate(mz_from, status);
 561                 UDate to = parseDate(mz_to, status);
 562                 if (U_FAILURE(status)) {
 563                     status = U_ZERO_ERROR;
 564                     continue;
 565                 }
 566
 567                 OlsonToMetaMappingEntry *entry = (OlsonToMetaMappingEntry*)uprv_malloc(sizeof(OlsonToMetaMappingEntry));
 568                 if (entry == NULL) {
 569                     status = U_MEMORY_ALLOCATION_ERROR;
 570                     break;
 571                 }
 572                 entry->mzid = mz_name;
 573                 entry->from = from;
 574                 entry->to = to;
 575
 576                 if (mzMappings == NULL) {
 577                     mzMappings = new UVector(deleteOlsonToMetaMappingEntry, NULL, status);
 578                     if (U_FAILURE(status)) {
 579                         delete mzMappings;
 580                         deleteOlsonToMetaMappingEntry(entry);
 581                         uprv_free(entry);
 582                         break;
 583                     }
 584                 }
 585
 586                 mzMappings->addElement(entry, status);
 587                 if (U_FAILURE(status)) {
 588                     break;
 589                 }
 590             }
 591             ures_close(mz);
 592             if (U_FAILURE(status)) {
 593                 if (mzMappings != NULL) {
 594                     delete mzMappings;
 595                     mzMappings = NULL;
 596                 }
 597             }
 598         }
 599     }
 600     ures_close(rb);
 601     return mzMappings;
 602 }
 603
 604 UnicodeString& U_EXPORT2
 605 ZoneMeta::getZoneIdByMetazone(const UnicodeString &mzid, const UnicodeString &region, UnicodeString &result) {
 606     UErrorCode status = U_ZERO_ERROR;
 607     const UChar *tzid = NULL;
 608     int32_t tzidLen = 0;
 609     char keyBuf[ZID_KEY_MAX + 1];
 610     int32_t keyLen = 0;
 611
 612     if (mzid.length() >= ZID_KEY_MAX) {
 613         result.remove();
 614         return result;
 615     }
 616
 617     keyLen = mzid.extract(0, mzid.length(), keyBuf, ZID_KEY_MAX, US_INV);
 618
 619     UResourceBundle *rb = ures_openDirect(NULL, gMetaZones, &status);
 620     ures_getByKey(rb, gMapTimezonesTag, rb, &status);
 621     ures_getByKey(rb, keyBuf, rb, &status);
 622
 623     if (U_SUCCESS(status)) {
 624         // check region mapping
 625         if (region.length() == 2 || region.length() == 3) {
 626             region.extract(0, region.length(), keyBuf, ZID_KEY_MAX, US_INV);
 627             tzid = ures_getStringByKey(rb, keyBuf, &tzidLen, &status);
 628             if (status == U_MISSING_RESOURCE_ERROR) {
 629                 status = U_ZERO_ERROR;
 630             }
 631         }
 632         if (U_SUCCESS(status) && tzid == NULL) {
 633             // try "001"
 634             tzid = ures_getStringByKey(rb, gWorldTag, &tzidLen, &status);
 635         }
 636     }
 637     ures_close(rb);
 638
 639     if (tzid == NULL) {
 640         result.remove();
 641     } else {
 642         result.setTo(tzid, tzidLen);
 643     }
 644
 645     return result;
 646 }
 647
 648 U_NAMESPACE_END
 649
 650 #endif /* #if !UCONFIG_NO_FORMATTING */