1 /* 2 ******************************************************************************* 3 * Copyright (C) 2011, International Business Machines Corporation and * 4 * others. All Rights Reserved. * 5 ******************************************************************************* 6 */ 7 8 #include "unicode/utypes.h" 9 10 #if !UCONFIG_NO_FORMATTING 11 12 #include "tzgnames.h" 13 14 #include "unicode/basictz.h" 15 #include "unicode/locdspnm.h" 16 #include "unicode/msgfmt.h" 17 #include "unicode/rbtz.h" 18 #include "unicode/simpletz.h" 19 #include "unicode/vtzone.h" 20 21 #include "cmemory.h" 22 #include "cstring.h" 23 #include "uhash.h" 24 #include "uassert.h" 25 #include "umutex.h" 26 #include "uresimp.h" 27 #include "ureslocs.h" 28 #include "zonemeta.h" 29 #include "tznames_impl.h" 30 #include "olsontz.h" 31 32 U_NAMESPACE_BEGIN 33 34 #define ZID_KEY_MAX 128 35 36 static const char gZoneStrings[] = "zoneStrings"; 37 38 static const char gRegionFormatTag[] = "regionFormat"; 39 static const char gFallbackRegionFormatTag[] = "fallbackRegionFormat"; 40 static const char gFallbackFormatTag[] = "fallbackFormat"; 41 42 static const UChar gEmpty[] = {0x00}; 43 44 static const UChar gDefRegionPattern[] = {0x7B, 0x30, 0x7D, 0x00}; // "{0}" 45 static const UChar gDefFallbackRegionPattern[] = {0x7B, 0x31, 0x7D, 0x20, 0x28, 0x7B, 0x30, 0x7D, 0x29, 0x00}; // "{1} ({0})" 46 static const UChar gDefFallbackPattern[] = {0x7B, 0x31, 0x7D, 0x20, 0x28, 0x7B, 0x30, 0x7D, 0x29, 0x00}; // "{1} ({0})" 47 48 static const double kDstCheckRange = (double)184*U_MILLIS_PER_DAY; 49 50 51 52 U_CDECL_BEGIN 53 54 typedef struct PartialLocationKey { 55 const UChar* tzID; 56 const UChar* mzID; 57 UBool isLong; 58 } PartialLocationKey; 59 60 /** 61 * Hash function for partial location name hash key 62 */ 63 static int32_t U_CALLCONV 64 hashPartialLocationKey(const UHashTok key) { 65 // <tzID>&<mzID>#[L|S] 66 PartialLocationKey *p = (PartialLocationKey *)key.pointer; 67 UnicodeString str(p->tzID); 68 str.append((UChar)0x26) 69 .append(p->mzID) 70 .append((UChar)0x23) 71 .append((UChar)(p->isLong ? 0x4C : 0x53)); 72 return uhash_hashUCharsN(str.getBuffer(), str.length()); 73 } 74 75 /** 76 * Comparer for partial location name hash key 77 */ 78 static UBool U_CALLCONV 79 comparePartialLocationKey(const UHashTok key1, const UHashTok key2) { 80 PartialLocationKey *p1 = (PartialLocationKey *)key1.pointer; 81 PartialLocationKey *p2 = (PartialLocationKey *)key2.pointer; 82 83 if (p1 == p2) { 84 return TRUE; 85 } 86 if (p1 == NULL || p2 == NULL) { 87 return FALSE; 88 } 89 // We just check identity of tzID/mzID 90 return (p1->tzID == p2->tzID && p1->mzID == p2->mzID && p1->isLong == p2->isLong); 91 } 92 93 /** 94 * Deleter for GNameInfo 95 */ 96 static void U_CALLCONV 97 deleteGNameInfo(void *obj) { 98 uprv_free(obj); 99 } 100 101 /** 102 * GNameInfo stores zone name information in the local trie 103 */ 104 typedef struct GNameInfo { 105 UTimeZoneGenericNameType type; 106 const UChar* tzID; 107 } ZNameInfo; 108 109 /** 110 * GMatchInfo stores zone name match information used by find method 111 */ 112 typedef struct GMatchInfo { 113 const GNameInfo* gnameInfo; 114 int32_t matchLength; 115 UTimeZoneTimeType timeType; 116 } ZMatchInfo; 117 118 U_CDECL_END 119 120 // --------------------------------------------------- 121 // The class stores time zone generic name match information 122 // --------------------------------------------------- 123 TimeZoneGenericNameMatchInfo::TimeZoneGenericNameMatchInfo(UVector* matches) 124 : fMatches(matches) { 125 } 126 127 TimeZoneGenericNameMatchInfo::~TimeZoneGenericNameMatchInfo() { 128 if (fMatches != NULL) { 129 delete fMatches; 130 } 131 } 132 133 int32_t 134 TimeZoneGenericNameMatchInfo::size() const { 135 if (fMatches == NULL) { 136 return 0; 137 } 138 return fMatches->size(); 139 } 140 141 UTimeZoneGenericNameType 142 TimeZoneGenericNameMatchInfo::getGenericNameType(int32_t index) const { 143 GMatchInfo *minfo = (GMatchInfo *)fMatches->elementAt(index); 144 if (minfo != NULL) { 145 return static_cast<UTimeZoneGenericNameType>(minfo->gnameInfo->type); 146 } 147 return UTZGNM_UNKNOWN; 148 } 149 150 int32_t 151 TimeZoneGenericNameMatchInfo::getMatchLength(int32_t index) const { 152 ZMatchInfo *minfo = (ZMatchInfo *)fMatches->elementAt(index); 153 if (minfo != NULL) { 154 return minfo->matchLength; 155 } 156 return -1; 157 } 158 159 UnicodeString& 160 TimeZoneGenericNameMatchInfo::getTimeZoneID(int32_t index, UnicodeString& tzID) const { 161 GMatchInfo *minfo = (GMatchInfo *)fMatches->elementAt(index); 162 if (minfo != NULL && minfo->gnameInfo->tzID != NULL) { 163 tzID.setTo(TRUE, minfo->gnameInfo->tzID, -1); 164 } else { 165 tzID.setToBogus(); 166 } 167 return tzID; 168 } 169 170 // --------------------------------------------------- 171 // GNameSearchHandler 172 // --------------------------------------------------- 173 class GNameSearchHandler : public TextTrieMapSearchResultHandler { 174 public: 175 GNameSearchHandler(uint32_t types); 176 virtual ~GNameSearchHandler(); 177 178 UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status); 179 UVector* getMatches(int32_t& maxMatchLen); 180 181 private: 182 uint32_t fTypes; 183 UVector* fResults; 184 int32_t fMaxMatchLen; 185 }; 186 187 GNameSearchHandler::GNameSearchHandler(uint32_t types) 188 : fTypes(types), fResults(NULL), fMaxMatchLen(0) { 189 } 190 191 GNameSearchHandler::~GNameSearchHandler() { 192 if (fResults != NULL) { 193 delete fResults; 194 } 195 } 196 197 UBool 198 GNameSearchHandler::handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status) { 199 if (U_FAILURE(status)) { 200 return FALSE; 201 } 202 if (node->hasValues()) { 203 int32_t valuesCount = node->countValues(); 204 for (int32_t i = 0; i < valuesCount; i++) { 205 GNameInfo *nameinfo = (ZNameInfo *)node->getValue(i); 206 if (nameinfo == NULL) { 207 break; 208 } 209 if ((nameinfo->type & fTypes) != 0) { 210 // matches a requested type 211 if (fResults == NULL) { 212 fResults = new UVector(uhash_freeBlock, NULL, status); 213 if (fResults == NULL) { 214 status = U_MEMORY_ALLOCATION_ERROR; 215 } 216 } 217 if (U_SUCCESS(status)) { 218 GMatchInfo *gmatch = (GMatchInfo *)uprv_malloc(sizeof(GMatchInfo)); 219 if (gmatch == NULL) { 220 status = U_MEMORY_ALLOCATION_ERROR; 221 } else { 222 // add the match to the vector 223 gmatch->gnameInfo = nameinfo; 224 gmatch->matchLength = matchLength; 225 gmatch->timeType = UTZFMT_TIME_TYPE_UNKNOWN; 226 fResults->addElement(gmatch, status); 227 if (U_FAILURE(status)) { 228 uprv_free(gmatch); 229 } else { 230 if (matchLength > fMaxMatchLen) { 231 fMaxMatchLen = matchLength; 232 } 233 } 234 } 235 } 236 } 237 } 238 } 239 return TRUE; 240 } 241 242 UVector* 243 GNameSearchHandler::getMatches(int32_t& maxMatchLen) { 244 // give the ownership to the caller 245 UVector *results = fResults; 246 maxMatchLen = fMaxMatchLen; 247 248 // reset 249 fResults = NULL; 250 fMaxMatchLen = 0; 251 return results; 252 } 253 254 // --------------------------------------------------- 255 // TimeZoneGenericNames 256 // 257 // TimeZoneGenericNames is parallel to TimeZoneNames, 258 // but handles run-time generated time zone names. 259 // This is the main part of this module. 260 // --------------------------------------------------- 261 TimeZoneGenericNames::TimeZoneGenericNames(const Locale& locale, UErrorCode& status) 262 : fLocale(locale), 263 fLock(NULL), 264 fTimeZoneNames(NULL), 265 fLocationNamesMap(NULL), 266 fPartialLocationNamesMap(NULL), 267 fRegionFormat(NULL), 268 fFallbackRegionFormat(NULL), 269 fFallbackFormat(NULL), 270 fLocaleDisplayNames(NULL), 271 fStringPool(status), 272 fGNamesTrie(TRUE, deleteGNameInfo), 273 fGNamesTrieFullyLoaded(FALSE) { 274 initialize(locale, status); 275 } 276 277 TimeZoneGenericNames::~TimeZoneGenericNames() { 278 cleanup(); 279 umtx_destroy(&fLock); 280 } 281 282 void 283 TimeZoneGenericNames::initialize(const Locale& locale, UErrorCode& status) { 284 if (U_FAILURE(status)) { 285 return; 286 } 287 288 // TimeZoneNames 289 fTimeZoneNames = TimeZoneNames::createInstance(locale, status); 290 if (U_FAILURE(status)) { 291 return; 292 } 293 294 // Initialize format patterns 295 UnicodeString rpat(TRUE, gDefRegionPattern, -1); 296 UnicodeString frpat(TRUE, gDefFallbackRegionPattern, -1); 297 UnicodeString fpat(TRUE, gDefFallbackPattern, -1); 298 299 UErrorCode tmpsts = U_ZERO_ERROR; // OK with fallback warning.. 300 UResourceBundle *zoneStrings = ures_open(U_ICUDATA_ZONE, locale.getName(), &tmpsts); 301 zoneStrings = ures_getByKeyWithFallback(zoneStrings, gZoneStrings, zoneStrings, &tmpsts); 302 303 if (U_SUCCESS(tmpsts)) { 304 const UChar *regionPattern = ures_getStringByKeyWithFallback(zoneStrings, gRegionFormatTag, NULL, &tmpsts); 305 if (U_SUCCESS(tmpsts) && u_strlen(regionPattern) > 0) { 306 rpat.setTo(regionPattern); 307 } 308 tmpsts = U_ZERO_ERROR; 309 const UChar *fallbackRegionPattern = ures_getStringByKeyWithFallback(zoneStrings, gFallbackRegionFormatTag, NULL, &tmpsts); 310 if (U_SUCCESS(tmpsts) && u_strlen(fallbackRegionPattern) > 0) { 311 frpat.setTo(fallbackRegionPattern); 312 } 313 tmpsts = U_ZERO_ERROR; 314 const UChar *fallbackPattern = ures_getStringByKeyWithFallback(zoneStrings, gFallbackFormatTag, NULL, &tmpsts); 315 if (U_SUCCESS(tmpsts) && u_strlen(fallbackPattern) > 0) { 316 fpat.setTo(fallbackPattern); 317 } 318 } 319 ures_close(zoneStrings); 320 321 fRegionFormat = new MessageFormat(rpat, status); 322 if (fRegionFormat == NULL) { 323 status = U_MEMORY_ALLOCATION_ERROR; 324 } 325 fFallbackRegionFormat = new MessageFormat(frpat, status); 326 if (fFallbackRegionFormat == NULL) { 327 status = U_MEMORY_ALLOCATION_ERROR; 328 } 329 fFallbackFormat = new MessageFormat(fpat, status); 330 if (fFallbackFormat == NULL) { 331 status = U_MEMORY_ALLOCATION_ERROR; 332 } 333 if (U_FAILURE(status)) { 334 cleanup(); 335 return; 336 } 337 338 // locale display names 339 fLocaleDisplayNames = LocaleDisplayNames::createInstance(locale); 340 341 // hash table for names - no key/value deleters 342 fLocationNamesMap = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status); 343 if (U_FAILURE(status)) { 344 cleanup(); 345 return; 346 } 347 348 fPartialLocationNamesMap = uhash_open(hashPartialLocationKey, comparePartialLocationKey, NULL, &status); 349 if (U_FAILURE(status)) { 350 cleanup(); 351 return; 352 } 353 uhash_setKeyDeleter(fPartialLocationNamesMap, uhash_freeBlock); 354 // no value deleter 355 356 // target region 357 const char* region = fLocale.getCountry(); 358 int32_t regionLen = uprv_strlen(region); 359 if (regionLen == 0) { 360 char loc[ULOC_FULLNAME_CAPACITY]; 361 uloc_addLikelySubtags(fLocale.getName(), loc, sizeof(loc), &status); 362 363 regionLen = uloc_getCountry(loc, fTargetRegion, sizeof(fTargetRegion), &status); 364 if (U_SUCCESS(status)) { 365 fTargetRegion[regionLen] = 0; 366 } else { 367 cleanup(); 368 return; 369 } 370 } else if (regionLen < (int32_t)sizeof(fTargetRegion)) { 371 uprv_strcpy(fTargetRegion, region); 372 } else { 373 fTargetRegion[0] = 0; 374 } 375 376 // preload generic names for the default zone 377 TimeZone *tz = TimeZone::createDefault(); 378 const UChar *tzID = ZoneMeta::getCanonicalCLDRID(*tz); 379 if (tzID != NULL) { 380 loadStrings(UnicodeString(tzID)); 381 } 382 delete tz; 383 } 384 385 void 386 TimeZoneGenericNames::cleanup() { 387 if (fRegionFormat != NULL) { 388 delete fRegionFormat; 389 } 390 if (fFallbackRegionFormat != NULL) { 391 delete fFallbackRegionFormat; 392 } 393 if (fFallbackFormat != NULL) { 394 delete fFallbackFormat; 395 } 396 if (fLocaleDisplayNames != NULL) { 397 delete fLocaleDisplayNames; 398 } 399 if (fTimeZoneNames != NULL) { 400 delete fTimeZoneNames; 401 } 402 403 uhash_close(fLocationNamesMap); 404 uhash_close(fPartialLocationNamesMap); 405 } 406 407 UnicodeString& 408 TimeZoneGenericNames::getDisplayName(const TimeZone& tz, UTimeZoneGenericNameType type, UDate date, UnicodeString& name) const { 409 name.setToBogus(); 410 switch (type) { 411 case UTZGNM_LOCATION: 412 { 413 const UChar* tzCanonicalID = ZoneMeta::getCanonicalCLDRID(tz); 414 if (tzCanonicalID != NULL) { 415 getGenericLocationName(UnicodeString(tzCanonicalID), name); 416 } 417 } 418 break; 419 case UTZGNM_LONG: 420 case UTZGNM_SHORT: 421 formatGenericNonLocationName(tz, type, date, name); 422 if (name.isEmpty()) { 423 const UChar* tzCanonicalID = ZoneMeta::getCanonicalCLDRID(tz); 424 if (tzCanonicalID != NULL) { 425 getGenericLocationName(UnicodeString(tzCanonicalID), name); 426 } 427 } 428 break; 429 default: 430 break; 431 } 432 return name; 433 } 434 435 UnicodeString& 436 TimeZoneGenericNames::getGenericLocationName(const UnicodeString& tzCanonicalID, UnicodeString& name) const { 437 if (tzCanonicalID.isEmpty()) { 438 name.setToBogus(); 439 return name; 440 } 441 442 const UChar *locname = NULL; 443 TimeZoneGenericNames *nonConstThis = const_cast<TimeZoneGenericNames *>(this); 444 umtx_lock(&nonConstThis->fLock); 445 { 446 locname = nonConstThis->getGenericLocationName(tzCanonicalID); 447 } 448 umtx_unlock(&nonConstThis->fLock); 449 450 if (locname == NULL) { 451 name.setToBogus(); 452 } else { 453 name.setTo(TRUE, locname, -1); 454 } 455 456 return name; 457 } 458 459 /* 460 * This method updates the cache and must be called with a lock 461 */ 462 const UChar* 463 TimeZoneGenericNames::getGenericLocationName(const UnicodeString& tzCanonicalID) { 464 U_ASSERT(!tzCanonicalID.isEmpty()); 465 if (tzCanonicalID.length() > ZID_KEY_MAX) { 466 return NULL; 467 } 468 469 UErrorCode status = U_ZERO_ERROR; 470 UChar tzIDKey[ZID_KEY_MAX + 1]; 471 int32_t tzIDKeyLen = tzCanonicalID.extract(tzIDKey, ZID_KEY_MAX + 1, status); 472 U_ASSERT(status == U_ZERO_ERROR); // already checked length above 473 tzIDKey[tzIDKeyLen] = 0; 474 475 const UChar *locname = (const UChar *)uhash_get(fLocationNamesMap, tzIDKey); 476 477 if (locname != NULL) { 478 // gEmpty indicate the name is not available 479 if (locname == gEmpty) { 480 return NULL; 481 } 482 return locname; 483 } 484 485 // Construct location name 486 UnicodeString name; 487 UBool isSingleCountry = FALSE; 488 UnicodeString usCountryCode; 489 ZoneMeta::getSingleCountry(tzCanonicalID, usCountryCode); 490 if (!usCountryCode.isEmpty()) { 491 isSingleCountry = TRUE; 492 } else { 493 ZoneMeta::getCanonicalCountry(tzCanonicalID, usCountryCode); 494 } 495 496 if (!usCountryCode.isEmpty()) { 497 char countryCode[ULOC_COUNTRY_CAPACITY]; 498 U_ASSERT(usCountryCode.length() < ULOC_COUNTRY_CAPACITY); 499 int32_t ccLen = usCountryCode.extract(0, usCountryCode.length(), countryCode, sizeof(countryCode), US_INV); 500 countryCode[ccLen] = 0; 501 502 UnicodeString country; 503 fLocaleDisplayNames->regionDisplayName(countryCode, country); 504 505 // Format 506 FieldPosition fpos; 507 if (isSingleCountry) { 508 // If the zone is only one zone in the country, do not add city 509 Formattable param[] = { 510 Formattable(country) 511 }; 512 fRegionFormat->format(param, 1, name, fpos, status); 513 } else { 514 // getExemplarLocationName should retur non-empty string 515 // if the time zone is associated with a region 516 UnicodeString city; 517 fTimeZoneNames->getExemplarLocationName(tzCanonicalID, city); 518 519 Formattable params[] = { 520 Formattable(city), 521 Formattable(country) 522 }; 523 fFallbackRegionFormat->format(params, 2, name, fpos, status); 524 } 525 if (U_FAILURE(status)) { 526 return NULL; 527 } 528 } 529 530 locname = name.isEmpty() ? NULL : fStringPool.get(name, status); 531 if (U_SUCCESS(status)) { 532 // Cache the result 533 const UChar* cacheID = ZoneMeta::findTimeZoneID(tzCanonicalID); 534 U_ASSERT(cacheID != NULL); 535 if (locname == NULL) { 536 // gEmpty to indicate - no location name available 537 uhash_put(fLocationNamesMap, (void *)cacheID, (void *)gEmpty, &status); 538 } else { 539 uhash_put(fLocationNamesMap, (void *)cacheID, (void *)locname, &status); 540 if (U_FAILURE(status)) { 541 locname = NULL; 542 } else { 543 // put the name info into the trie 544 GNameInfo *nameinfo = (ZNameInfo *)uprv_malloc(sizeof(GNameInfo)); 545 if (nameinfo != NULL) { 546 nameinfo->type = UTZGNM_LOCATION; 547 nameinfo->tzID = cacheID; 548 fGNamesTrie.put(locname, nameinfo, status); 549 } 550 } 551 } 552 } 553 554 return locname; 555 } 556 557 UnicodeString& 558 TimeZoneGenericNames::formatGenericNonLocationName(const TimeZone& tz, UTimeZoneGenericNameType type, UDate date, UnicodeString& name) const { 559 U_ASSERT(type == UTZGNM_LONG || type == UTZGNM_SHORT); 560 name.setToBogus(); 561 562 const UChar* uID = ZoneMeta::getCanonicalCLDRID(tz); 563 if (uID == NULL) { 564 return name; 565 } 566 567 UnicodeString tzID(uID); 568 569 // Try to get a name from time zone first 570 UTimeZoneNameType nameType = (type == UTZGNM_LONG) ? UTZNM_LONG_GENERIC : UTZNM_SHORT_GENERIC; 571 fTimeZoneNames->getTimeZoneDisplayName(tzID, nameType, name); 572 573 if (!name.isEmpty()) { 574 return name; 575 } 576 577 // Try meta zone 578 UnicodeString mzID; 579 fTimeZoneNames->getMetaZoneID(tzID, date, mzID); 580 if (!mzID.isEmpty()) { 581 UErrorCode status = U_ZERO_ERROR; 582 UBool useStandard = FALSE; 583 int32_t raw, sav; 584 585 tz.getOffset(date, FALSE, raw, sav, status); 586 if (U_FAILURE(status)) { 587 return name; 588 } 589 590 if (sav == 0) { 591 useStandard = TRUE; 592 593 TimeZone *tmptz = tz.clone(); 594 // Check if the zone actually uses daylight saving time around the time 595 BasicTimeZone *btz = NULL; 596 if (dynamic_cast<OlsonTimeZone *>(tmptz) != NULL 597 || dynamic_cast<SimpleTimeZone *>(tmptz) != NULL 598 || dynamic_cast<RuleBasedTimeZone *>(tmptz) != NULL 599 || dynamic_cast<VTimeZone *>(tmptz) != NULL) { 600 btz = (BasicTimeZone*)tmptz; 601 } 602 603 if (btz != NULL) { 604 TimeZoneTransition before; 605 UBool beforTrs = btz->getPreviousTransition(date, TRUE, before); 606 if (beforTrs 607 && (date - before.getTime() < kDstCheckRange) 608 && before.getFrom()->getDSTSavings() != 0) { 609 useStandard = FALSE; 610 } else { 611 TimeZoneTransition after; 612 UBool afterTrs = btz->getNextTransition(date, FALSE, after); 613 if (afterTrs 614 && (after.getTime() - date < kDstCheckRange) 615 && after.getTo()->getDSTSavings() != 0) { 616 useStandard = FALSE; 617 } 618 } 619 } else { 620 // If not BasicTimeZone... only if the instance is not an ICU's implementation. 621 // We may get a wrong answer in edge case, but it should practically work OK. 622 tmptz->getOffset(date - kDstCheckRange, FALSE, raw, sav, status); 623 if (sav != 0) { 624 useStandard = FALSE; 625 } else { 626 tmptz->getOffset(date + kDstCheckRange, FALSE, raw, sav, status); 627 if (sav != 0){ 628 useStandard = FALSE; 629 } 630 } 631 if (U_FAILURE(status)) { 632 delete tmptz; 633 return name; 634 } 635 } 636 delete tmptz; 637 } 638 if (useStandard) { 639 UTimeZoneNameType stdNameType = (nameType == UTZNM_LONG_GENERIC) 640 ? UTZNM_LONG_STANDARD : UTZNM_SHORT_STANDARD_COMMONLY_USED; 641 UnicodeString stdName; 642 fTimeZoneNames->getDisplayName(tzID, stdNameType, date, stdName); 643 if (!stdName.isEmpty()) { 644 name.setTo(stdName); 645 646 // TODO: revisit this issue later 647 // In CLDR, a same display name is used for both generic and standard 648 // for some meta zones in some locales. This looks like a data bugs. 649 // For now, we check if the standard name is different from its generic 650 // name below. 651 UnicodeString mzGenericName; 652 fTimeZoneNames->getMetaZoneDisplayName(mzID, nameType, mzGenericName); 653 if (stdName.caseCompare(mzGenericName, 0) == 0) { 654 name.setToBogus(); 655 } 656 } 657 } 658 if (name.isEmpty()) { 659 // Get a name from meta zone 660 UnicodeString mzName; 661 fTimeZoneNames->getMetaZoneDisplayName(mzID, nameType, mzName); 662 if (!mzName.isEmpty()) { 663 // Check if we need to use a partial location format. 664 // This check is done by comparing offset with the meta zone's 665 // golden zone at the given date. 666 UnicodeString goldenID; 667 fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, goldenID); 668 if (!goldenID.isEmpty() && goldenID != tzID) { 669 TimeZone *goldenZone = TimeZone::createTimeZone(goldenID); 670 int32_t raw1, sav1; 671 672 // Check offset in the golden zone with wall time. 673 // With getOffset(date, false, offsets1), 674 // you may get incorrect results because of time overlap at DST->STD 675 // transition. 676 goldenZone->getOffset(date + raw + sav, TRUE, raw1, sav1, status); 677 delete goldenZone; 678 if (U_SUCCESS(status)) { 679 if (raw != raw1 || sav != sav1) { 680 // Now we need to use a partial location format 681 getPartialLocationName(tzID, mzID, (nameType == UTZNM_LONG_GENERIC), mzName, name); 682 } else { 683 name.setTo(mzName); 684 } 685 } 686 } else { 687 name.setTo(mzName); 688 } 689 } 690 } 691 } 692 return name; 693 } 694 695 UnicodeString& 696 TimeZoneGenericNames::getPartialLocationName(const UnicodeString& tzCanonicalID, 697 const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName, 698 UnicodeString& name) const { 699 name.setToBogus(); 700 if (tzCanonicalID.isEmpty() || mzID.isEmpty() || mzDisplayName.isEmpty()) { 701 return name; 702 } 703 704 const UChar *uplname = NULL; 705 TimeZoneGenericNames *nonConstThis = const_cast<TimeZoneGenericNames *>(this); 706 umtx_lock(&nonConstThis->fLock); 707 { 708 uplname = nonConstThis->getPartialLocationName(tzCanonicalID, mzID, isLong, mzDisplayName); 709 } 710 umtx_unlock(&nonConstThis->fLock); 711 712 if (uplname == NULL) { 713 name.setToBogus(); 714 } else { 715 name.setTo(TRUE, uplname, -1); 716 } 717 return name; 718 } 719 720 /* 721 * This method updates the cache and must be called with a lock 722 */ 723 const UChar* 724 TimeZoneGenericNames::getPartialLocationName(const UnicodeString& tzCanonicalID, 725 const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName) { 726 U_ASSERT(!tzCanonicalID.isEmpty()); 727 U_ASSERT(!mzID.isEmpty()); 728 U_ASSERT(!mzDisplayName.isEmpty()); 729 730 PartialLocationKey key; 731 key.tzID = ZoneMeta::findTimeZoneID(tzCanonicalID); 732 key.mzID = ZoneMeta::findMetaZoneID(mzID); 733 key.isLong = isLong; 734 U_ASSERT(key.tzID != NULL && key.mzID != NULL); 735 736 const UChar* uplname = (const UChar*)uhash_get(fPartialLocationNamesMap, (void *)&key); 737 if (uplname != NULL) { 738 return uplname; 739 } 740 741 UnicodeString location; 742 UnicodeString usCountryCode; 743 ZoneMeta::getCanonicalCountry(tzCanonicalID, usCountryCode); 744 if (!usCountryCode.isEmpty()) { 745 char countryCode[ULOC_COUNTRY_CAPACITY]; 746 U_ASSERT(usCountryCode.length() < ULOC_COUNTRY_CAPACITY); 747 int32_t ccLen = usCountryCode.extract(0, usCountryCode.length(), countryCode, sizeof(countryCode), US_INV); 748 countryCode[ccLen] = 0; 749 750 UnicodeString regionalGolden; 751 fTimeZoneNames->getReferenceZoneID(mzID, countryCode, regionalGolden); 752 if (tzCanonicalID == regionalGolden) { 753 // Use country name 754 fLocaleDisplayNames->regionDisplayName(countryCode, location); 755 } else { 756 // Otherwise, use exemplar city name 757 fTimeZoneNames->getExemplarLocationName(tzCanonicalID, location); 758 } 759 } else { 760 fTimeZoneNames->getExemplarLocationName(tzCanonicalID, location); 761 if (location.isEmpty()) { 762 // This could happen when the time zone is not associated with a country, 763 // and its ID is not hierarchical, for example, CST6CDT. 764 // We use the canonical ID itself as the location for this case. 765 location.setTo(tzCanonicalID); 766 } 767 } 768 769 UErrorCode status = U_ZERO_ERROR; 770 UnicodeString name; 771 772 FieldPosition fpos; 773 Formattable param[] = { 774 Formattable(location), 775 Formattable(mzDisplayName) 776 }; 777 fFallbackFormat->format(param, 2, name, fpos, status); 778 if (U_FAILURE(status)) { 779 return NULL; 780 } 781 782 uplname = fStringPool.get(name, status); 783 if (U_SUCCESS(status)) { 784 // Add the name to cache 785 PartialLocationKey* cacheKey = (PartialLocationKey *)uprv_malloc(sizeof(PartialLocationKey)); 786 if (cacheKey != NULL) { 787 cacheKey->tzID = key.tzID; 788 cacheKey->mzID = key.mzID; 789 cacheKey->isLong = key.isLong; 790 uhash_put(fPartialLocationNamesMap, (void *)cacheKey, (void *)uplname, &status); 791 if (U_FAILURE(status)) { 792 uprv_free(cacheKey); 793 } else { 794 // put the name to the local trie as well 795 GNameInfo *nameinfo = (ZNameInfo *)uprv_malloc(sizeof(GNameInfo)); 796 if (nameinfo != NULL) { 797 nameinfo->type = isLong ? UTZGNM_LONG : UTZGNM_SHORT; 798 nameinfo->tzID = key.tzID; 799 fGNamesTrie.put(uplname, nameinfo, status); 800 } 801 } 802 } 803 } 804 return uplname; 805 } 806 807 /* 808 * This method updates the cache and must be called with a lock, 809 * except initializer. 810 */ 811 void 812 TimeZoneGenericNames::loadStrings(const UnicodeString& tzCanonicalID) { 813 // load the generic location name 814 getGenericLocationName(tzCanonicalID); 815 816 // partial location names 817 UErrorCode status = U_ZERO_ERROR; 818 819 const UnicodeString *mzID; 820 UnicodeString goldenID; 821 UnicodeString mzGenName; 822 UTimeZoneNameType genNonLocTypes[] = { 823 UTZNM_LONG_GENERIC, UTZNM_SHORT_GENERIC, 824 UTZNM_UNKNOWN /*terminator*/ 825 }; 826 827 StringEnumeration *mzIDs = fTimeZoneNames->getAvailableMetaZoneIDs(tzCanonicalID, status); 828 while ((mzID = mzIDs->snext(status))) { 829 if (U_FAILURE(status)) { 830 break; 831 } 832 // if this time zone is not the golden zone of the meta zone, 833 // partial location name (such as "PT (Los Angeles)") might be 834 // available. 835 fTimeZoneNames->getReferenceZoneID(*mzID, fTargetRegion, goldenID); 836 if (tzCanonicalID != goldenID) { 837 for (int32_t i = 0; genNonLocTypes[i] != UTZNM_UNKNOWN; i++) { 838 fTimeZoneNames->getMetaZoneDisplayName(*mzID, genNonLocTypes[i], mzGenName); 839 if (!mzGenName.isEmpty()) { 840 // getPartialLocationName formats a name and put it into the trie 841 getPartialLocationName(tzCanonicalID, *mzID, 842 (genNonLocTypes[i] == UTZNM_LONG_GENERIC), mzGenName); 843 } 844 } 845 } 846 } 847 if (mzIDs != NULL) { 848 delete mzIDs; 849 } 850 } 851 852 int32_t 853 TimeZoneGenericNames::findBestMatch(const UnicodeString& text, int32_t start, uint32_t types, 854 UnicodeString& tzID, UTimeZoneTimeType& timeType, UErrorCode& status) const { 855 timeType = UTZFMT_TIME_TYPE_UNKNOWN; 856 tzID.setToBogus(); 857 858 if (U_FAILURE(status)) { 859 return 0; 860 } 861 862 // Find matches in the TimeZoneNames first 863 TimeZoneNameMatchInfo *tznamesMatches = findTimeZoneNames(text, start, types, status); 864 if (U_FAILURE(status)) { 865 return 0; 866 } 867 868 int32_t bestMatchLen = 0; 869 UTimeZoneTimeType bestMatchTimeType = UTZFMT_TIME_TYPE_UNKNOWN; 870 UnicodeString bestMatchTzID; 871 UBool isLongStandard = FALSE; // workaround - see the comments below 872 873 if (tznamesMatches != NULL) { 874 UnicodeString mzID; 875 for (int32_t i = 0; i < tznamesMatches->size(); i++) { 876 int32_t len = tznamesMatches->getMatchLength(i); 877 if (len > bestMatchLen) { 878 bestMatchLen = len; 879 tznamesMatches->getTimeZoneID(i, bestMatchTzID); 880 if (bestMatchTzID.isEmpty()) { 881 // name for a meta zone 882 tznamesMatches->getMetaZoneID(i, mzID); 883 U_ASSERT(mzID.length() > 0); 884 fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, bestMatchTzID); 885 } 886 UTimeZoneNameType nameType = tznamesMatches->getNameType(i); 887 switch (nameType) { 888 case UTZNM_LONG_STANDARD: 889 isLongStandard = TRUE; 890 case UTZNM_SHORT_STANDARD_COMMONLY_USED: 891 case UTZNM_SHORT_STANDARD: // this one is never used for generic, but just in case 892 bestMatchTimeType = UTZFMT_TIME_TYPE_STANDARD; 893 break; 894 case UTZNM_LONG_DAYLIGHT: 895 case UTZNM_SHORT_DAYLIGHT_COMMONLY_USED: 896 case UTZNM_SHORT_DAYLIGHT: // this one is never used for generic, but just in case 897 bestMatchTimeType = UTZFMT_TIME_TYPE_DAYLIGHT; 898 break; 899 default: 900 bestMatchTimeType = UTZFMT_TIME_TYPE_UNKNOWN; 901 } 902 } 903 } 904 delete tznamesMatches; 905 906 if (bestMatchLen == (text.length() - start)) { 907 // Full match 908 909 //tzID.setTo(bestMatchTzID); 910 //timeType = bestMatchTimeType; 911 //return bestMatchLen; 912 913 // TODO Some time zone uses a same name for the long standard name 914 // and the location name. When the match is a long standard name, 915 // then we need to check if the name is same with the location name. 916 // This is probably a data error or a design bug. 917 if (!isLongStandard) { 918 tzID.setTo(bestMatchTzID); 919 timeType = bestMatchTimeType; 920 return bestMatchLen; 921 } 922 } 923 } 924 925 // Find matches in the local trie 926 TimeZoneGenericNameMatchInfo *localMatches = findLocal(text, start, types, status); 927 if (U_FAILURE(status)) { 928 return 0; 929 } 930 if (localMatches != NULL) { 931 for (int32_t i = 0; i < localMatches->size(); i++) { 932 int32_t len = localMatches->getMatchLength(i); 933 934 // TODO See the above TODO. We use len >= bestMatchLen 935 // because of the long standard/location name collision 936 // problem. If it is also a location name, carrying 937 // timeType = UTZFMT_TIME_TYPE_STANDARD will cause a 938 // problem in SimpleDateFormat 939 if (len >= bestMatchLen) { 940 bestMatchLen = localMatches->getMatchLength(i); 941 bestMatchTimeType = UTZFMT_TIME_TYPE_UNKNOWN; // because generic 942 localMatches->getTimeZoneID(i, bestMatchTzID); 943 } 944 } 945 delete localMatches; 946 } 947 948 if (bestMatchLen > 0) { 949 timeType = bestMatchTimeType; 950 tzID.setTo(bestMatchTzID); 951 } 952 return bestMatchLen; 953 } 954 955 TimeZoneGenericNameMatchInfo* 956 TimeZoneGenericNames::findLocal(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const { 957 GNameSearchHandler handler(types); 958 959 TimeZoneGenericNames *nonConstThis = const_cast<TimeZoneGenericNames *>(this); 960 961 umtx_lock(&nonConstThis->fLock); 962 { 963 fGNamesTrie.search(text, start, (TextTrieMapSearchResultHandler *)&handler, status); 964 } 965 umtx_unlock(&nonConstThis->fLock); 966 967 if (U_FAILURE(status)) { 968 return NULL; 969 } 970 971 TimeZoneGenericNameMatchInfo *gmatchInfo = NULL; 972 973 int32_t maxLen = 0; 974 UVector *results = handler.getMatches(maxLen); 975 if (results != NULL && ((maxLen == (text.length() - start)) || fGNamesTrieFullyLoaded)) { 976 // perfect match 977 gmatchInfo = new TimeZoneGenericNameMatchInfo(results); 978 if (gmatchInfo == NULL) { 979 status = U_MEMORY_ALLOCATION_ERROR; 980 delete results; 981 return NULL; 982 } 983 return gmatchInfo; 984 } 985 986 if (results != NULL) { 987 delete results; 988 } 989 990 // All names are not yet loaded into the local trie. 991 // Load all available names into the trie. This could be very heavy. 992 umtx_lock(&nonConstThis->fLock); 993 { 994 if (!fGNamesTrieFullyLoaded) { 995 StringEnumeration *tzIDs = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL, NULL, NULL, status); 996 if (U_SUCCESS(status)) { 997 const UnicodeString *tzID; 998 while ((tzID = tzIDs->snext(status))) { 999 if (U_FAILURE(status)) { 1000 break; 1001 } 1002 nonConstThis->loadStrings(*tzID); 1003 } 1004 } 1005 if (tzIDs != NULL) { 1006 delete tzIDs; 1007 } 1008 1009 if (U_SUCCESS(status)) { 1010 nonConstThis->fGNamesTrieFullyLoaded = TRUE; 1011 } 1012 } 1013 } 1014 umtx_unlock(&nonConstThis->fLock); 1015 1016 if (U_FAILURE(status)) { 1017 return NULL; 1018 } 1019 1020 umtx_lock(&nonConstThis->fLock); 1021 { 1022 // now try it again 1023 fGNamesTrie.search(text, start, (TextTrieMapSearchResultHandler *)&handler, status); 1024 } 1025 umtx_unlock(&nonConstThis->fLock); 1026 1027 results = handler.getMatches(maxLen); 1028 if (results != NULL && maxLen > 0) { 1029 gmatchInfo = new TimeZoneGenericNameMatchInfo(results); 1030 if (gmatchInfo == NULL) { 1031 status = U_MEMORY_ALLOCATION_ERROR; 1032 delete results; 1033 return NULL; 1034 } 1035 } 1036 1037 return gmatchInfo; 1038 } 1039 1040 TimeZoneNameMatchInfo* 1041 TimeZoneGenericNames::findTimeZoneNames(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const { 1042 TimeZoneNameMatchInfo *matchInfo = NULL; 1043 1044 // Check if the target name typs is really in the TimeZoneNames 1045 uint32_t nameTypes = 0; 1046 if (types & UTZGNM_LONG) { 1047 nameTypes |= (UTZNM_LONG_GENERIC | UTZNM_LONG_STANDARD); 1048 } 1049 if (types & UTZGNM_SHORT) { 1050 nameTypes |= (UTZNM_SHORT_GENERIC | UTZNM_SHORT_STANDARD_COMMONLY_USED); 1051 } 1052 1053 if (types) { 1054 // Find matches in the TimeZoneNames 1055 matchInfo = fTimeZoneNames->find(text, start, nameTypes, status); 1056 } 1057 1058 return matchInfo; 1059 } 1060 1061 U_NAMESPACE_END 1062 #endif 1063