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