icuSources/i18n/tzgnames.cpp

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 *******************************************************************************
   5 * Copyright (C) 2011-2016, International Business Machines Corporation and
   6 * others. All Rights Reserved.
   7 *******************************************************************************
   8 */
   9
  10 #include "unicode/utypes.h"
  11
  12 #if !UCONFIG_NO_FORMATTING
  13
  14 #include "tzgnames.h"
  15
  16 #include "unicode/basictz.h"
  17 #include "unicode/locdspnm.h"
  18 #include "unicode/rbtz.h"
  19 #include "unicode/simpleformatter.h"
  20 #include "unicode/simpletz.h"
  21 #include "unicode/strenum.h"
  22 #include "unicode/vtzone.h"
  23
  24 #include "cmemory.h"
  25 #include "cstring.h"
  26 #include "mutex.h"
  27 #include "uhash.h"
  28 #include "uassert.h"
  29 #include "umutex.h"
  30 #include "uresimp.h"
  31 #include "ureslocs.h"
  32 #include "zonemeta.h"
  33 #include "tznames_impl.h"
  34 #include "olsontz.h"
  35 #include "ucln_in.h"
  36
  37 U_NAMESPACE_BEGIN
  38
  39 #define ZID_KEY_MAX  128
  40
  41 static const char gZoneStrings[]                = "zoneStrings";
  42
  43 static const char gRegionFormatTag[]            = "regionFormat";
  44 static const char gFallbackFormatTag[]          = "fallbackFormat";
  45
  46 static const UChar gEmpty[]                     = {0x00};
  47
  48 static const UChar gDefRegionPattern[]          = {0x7B, 0x30, 0x7D, 0x00}; // "{0}"
  49 static const UChar gDefFallbackPattern[]        = {0x7B, 0x31, 0x7D, 0x20, 0x28, 0x7B, 0x30, 0x7D, 0x29, 0x00}; // "{1} ({0})"
  50
  51 static const double kDstCheckRange      = (double)184*U_MILLIS_PER_DAY;
  52
  53
  54
  55 U_CDECL_BEGIN
  56
  57 typedef struct PartialLocationKey {
  58     const UChar* tzID;
  59     const UChar* mzID;
  60     UBool isLong;
  61 } PartialLocationKey;
  62
  63 /**
  64  * Hash function for partial location name hash key
  65  */
  66 static int32_t U_CALLCONV
  67 hashPartialLocationKey(const UHashTok key) {
  68     // <tzID>&<mzID>#[L|S]
  69     PartialLocationKey *p = (PartialLocationKey *)key.pointer;
  70     UnicodeString str(p->tzID);
  71     str.append((UChar)0x26)
  72         .append(p->mzID, -1)
  73         .append((UChar)0x23)
  74         .append((UChar)(p->isLong ? 0x4C : 0x53));
  75     return str.hashCode();
  76 }
  77
  78 /**
  79  * Comparer for partial location name hash key
  80  */
  81 static UBool U_CALLCONV
  82 comparePartialLocationKey(const UHashTok key1, const UHashTok key2) {
  83     PartialLocationKey *p1 = (PartialLocationKey *)key1.pointer;
  84     PartialLocationKey *p2 = (PartialLocationKey *)key2.pointer;
  85
  86     if (p1 == p2) {
  87         return TRUE;
  88     }
  89     if (p1 == NULL || p2 == NULL) {
  90         return FALSE;
  91     }
  92     // We just check identity of tzID/mzID
  93     return (p1->tzID == p2->tzID && p1->mzID == p2->mzID && p1->isLong == p2->isLong);
  94 }
  95
  96 /**
  97  * Deleter for GNameInfo
  98  */
  99 static void U_CALLCONV
 100 deleteGNameInfo(void *obj) {
 101     uprv_free(obj);
 102 }
 103
 104 /**
 105  * GNameInfo stores zone name information in the local trie
 106  */
 107 typedef struct GNameInfo {
 108     UTimeZoneGenericNameType    type;
 109     const UChar*                tzID;
 110 } ZNameInfo;
 111
 112 /**
 113  * GMatchInfo stores zone name match information used by find method
 114  */
 115 typedef struct GMatchInfo {
 116     const GNameInfo*    gnameInfo;
 117     int32_t             matchLength;
 118     UTimeZoneFormatTimeType   timeType;
 119 } ZMatchInfo;
 120
 121 U_CDECL_END
 122
 123 // ---------------------------------------------------
 124 // The class stores time zone generic name match information
 125 // ---------------------------------------------------
 126 class TimeZoneGenericNameMatchInfo : public UMemory {
 127 public:
 128     TimeZoneGenericNameMatchInfo(UVector* matches);
 129     ~TimeZoneGenericNameMatchInfo();
 130
 131     int32_t size() const;
 132     UTimeZoneGenericNameType getGenericNameType(int32_t index) const;
 133     int32_t getMatchLength(int32_t index) const;
 134     UnicodeString& getTimeZoneID(int32_t index, UnicodeString& tzID) const;
 135
 136 private:
 137     UVector* fMatches;  // vector of MatchEntry
 138 };
 139
 140 TimeZoneGenericNameMatchInfo::TimeZoneGenericNameMatchInfo(UVector* matches)
 141 : fMatches(matches) {
 142 }
 143
 144 TimeZoneGenericNameMatchInfo::~TimeZoneGenericNameMatchInfo() {
 145     if (fMatches != NULL) {
 146         delete fMatches;
 147     }
 148 }
 149
 150 int32_t
 151 TimeZoneGenericNameMatchInfo::size() const {
 152     if (fMatches == NULL) {
 153         return 0;
 154     }
 155     return fMatches->size();
 156 }
 157
 158 UTimeZoneGenericNameType
 159 TimeZoneGenericNameMatchInfo::getGenericNameType(int32_t index) const {
 160     GMatchInfo *minfo = (GMatchInfo *)fMatches->elementAt(index);
 161     if (minfo != NULL) {
 162         return static_cast<UTimeZoneGenericNameType>(minfo->gnameInfo->type);
 163     }
 164     return UTZGNM_UNKNOWN;
 165 }
 166
 167 int32_t
 168 TimeZoneGenericNameMatchInfo::getMatchLength(int32_t index) const {
 169     ZMatchInfo *minfo = (ZMatchInfo *)fMatches->elementAt(index);
 170     if (minfo != NULL) {
 171         return minfo->matchLength;
 172     }
 173     return -1;
 174 }
 175
 176 UnicodeString&
 177 TimeZoneGenericNameMatchInfo::getTimeZoneID(int32_t index, UnicodeString& tzID) const {
 178     GMatchInfo *minfo = (GMatchInfo *)fMatches->elementAt(index);
 179     if (minfo != NULL && minfo->gnameInfo->tzID != NULL) {
 180         tzID.setTo(TRUE, minfo->gnameInfo->tzID, -1);
 181     } else {
 182         tzID.setToBogus();
 183     }
 184     return tzID;
 185 }
 186
 187 // ---------------------------------------------------
 188 // GNameSearchHandler
 189 // ---------------------------------------------------
 190 class GNameSearchHandler : public TextTrieMapSearchResultHandler {
 191 public:
 192     GNameSearchHandler(uint32_t types);
 193     virtual ~GNameSearchHandler();
 194
 195     UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status);
 196     UVector* getMatches(int32_t& maxMatchLen);
 197
 198 private:
 199     uint32_t fTypes;
 200     UVector* fResults;
 201     int32_t fMaxMatchLen;
 202 };
 203
 204 GNameSearchHandler::GNameSearchHandler(uint32_t types)
 205 : fTypes(types), fResults(NULL), fMaxMatchLen(0) {
 206 }
 207
 208 GNameSearchHandler::~GNameSearchHandler() {
 209     if (fResults != NULL) {
 210         delete fResults;
 211     }
 212 }
 213
 214 UBool
 215 GNameSearchHandler::handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status) {
 216     if (U_FAILURE(status)) {
 217         return FALSE;
 218     }
 219     if (node->hasValues()) {
 220         int32_t valuesCount = node->countValues();
 221         for (int32_t i = 0; i < valuesCount; i++) {
 222             GNameInfo *nameinfo = (ZNameInfo *)node->getValue(i);
 223             if (nameinfo == NULL) {
 224                 break;
 225             }
 226             if ((nameinfo->type & fTypes) != 0) {
 227                 // matches a requested type
 228                 if (fResults == NULL) {
 229                     fResults = new UVector(uprv_free, NULL, status);
 230                     if (fResults == NULL) {
 231                         status = U_MEMORY_ALLOCATION_ERROR;
 232                     }
 233                 }
 234                 if (U_SUCCESS(status)) {
 235                     U_ASSERT(fResults != NULL);
 236                     GMatchInfo *gmatch = (GMatchInfo *)uprv_malloc(sizeof(GMatchInfo));
 237                     if (gmatch == NULL) {
 238                         status = U_MEMORY_ALLOCATION_ERROR;
 239                     } else {
 240                         // add the match to the vector
 241                         gmatch->gnameInfo = nameinfo;
 242                         gmatch->matchLength = matchLength;
 243                         gmatch->timeType = UTZFMT_TIME_TYPE_UNKNOWN;
 244                         fResults->addElement(gmatch, status);
 245                         if (U_FAILURE(status)) {
 246                             uprv_free(gmatch);
 247                         } else {
 248                             if (matchLength > fMaxMatchLen) {
 249                                 fMaxMatchLen = matchLength;
 250                             }
 251                         }
 252                     }
 253                 }
 254             }
 255         }
 256     }
 257     return TRUE;
 258 }
 259
 260 UVector*
 261 GNameSearchHandler::getMatches(int32_t& maxMatchLen) {
 262     // give the ownership to the caller
 263     UVector *results = fResults;
 264     maxMatchLen = fMaxMatchLen;
 265
 266     // reset
 267     fResults = NULL;
 268     fMaxMatchLen = 0;
 269     return results;
 270 }
 271
 272 static UMutex gLock = U_MUTEX_INITIALIZER;
 273
 274 class TZGNCore : public UMemory {
 275 public:
 276     TZGNCore(const Locale& locale, UErrorCode& status);
 277     virtual ~TZGNCore();
 278
 279     UnicodeString& getDisplayName(const TimeZone& tz, UTimeZoneGenericNameType type,
 280                         UDate date, UnicodeString& name) const;
 281
 282     UnicodeString& getGenericLocationName(const UnicodeString& tzCanonicalID, UnicodeString& name) const;
 283
 284     int32_t findBestMatch(const UnicodeString& text, int32_t start, uint32_t types,
 285         UnicodeString& tzID, UTimeZoneFormatTimeType& timeType, UErrorCode& status) const;
 286
 287 private:
 288     Locale fLocale;
 289     const TimeZoneNames* fTimeZoneNames;
 290     UHashtable* fLocationNamesMap;
 291     UHashtable* fPartialLocationNamesMap;
 292
 293     SimpleFormatter fRegionFormat;
 294     SimpleFormatter fFallbackFormat;
 295
 296     LocaleDisplayNames* fLocaleDisplayNames;
 297     ZNStringPool fStringPool;
 298
 299     TextTrieMap fGNamesTrie;
 300     UBool fGNamesTrieFullyLoaded;
 301
 302     char fTargetRegion[ULOC_COUNTRY_CAPACITY];
 303
 304     void initialize(const Locale& locale, UErrorCode& status);
 305     void cleanup();
 306
 307     void loadStrings(const UnicodeString& tzCanonicalID);
 308
 309     const UChar* getGenericLocationName(const UnicodeString& tzCanonicalID);
 310
 311     UnicodeString& formatGenericNonLocationName(const TimeZone& tz, UTimeZoneGenericNameType type,
 312                         UDate date, UnicodeString& name) const;
 313
 314     UnicodeString& getPartialLocationName(const UnicodeString& tzCanonicalID,
 315                         const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName,
 316                         UnicodeString& name) const;
 317
 318     const UChar* getPartialLocationName(const UnicodeString& tzCanonicalID,
 319                         const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName);
 320
 321     TimeZoneGenericNameMatchInfo* findLocal(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const;
 322
 323     TimeZoneNames::MatchInfoCollection* findTimeZoneNames(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const;
 324 };
 325
 326
 327 // ---------------------------------------------------
 328 // TZGNCore - core implmentation of TimeZoneGenericNames
 329 //
 330 // TimeZoneGenericNames is parallel to TimeZoneNames,
 331 // but handles run-time generated time zone names.
 332 // This is the main part of this module.
 333 // ---------------------------------------------------
 334 TZGNCore::TZGNCore(const Locale& locale, UErrorCode& status)
 335 : fLocale(locale),
 336   fTimeZoneNames(NULL),
 337   fLocationNamesMap(NULL),
 338   fPartialLocationNamesMap(NULL),
 339   fLocaleDisplayNames(NULL),
 340   fStringPool(status),
 341   fGNamesTrie(TRUE, deleteGNameInfo),
 342   fGNamesTrieFullyLoaded(FALSE) {
 343     initialize(locale, status);
 344 }
 345
 346 TZGNCore::~TZGNCore() {
 347     cleanup();
 348 }
 349
 350 void
 351 TZGNCore::initialize(const Locale& locale, UErrorCode& status) {
 352     if (U_FAILURE(status)) {
 353         return;
 354     }
 355
 356     // TimeZoneNames
 357     fTimeZoneNames = TimeZoneNames::createInstance(locale, status);
 358     if (U_FAILURE(status)) {
 359         return;
 360     }
 361
 362     // Initialize format patterns
 363     UnicodeString rpat(TRUE, gDefRegionPattern, -1);
 364     UnicodeString fpat(TRUE, gDefFallbackPattern, -1);
 365
 366     UErrorCode tmpsts = U_ZERO_ERROR;   // OK with fallback warning..
 367     UResourceBundle *zoneStrings = ures_open(U_ICUDATA_ZONE, locale.getName(), &tmpsts);
 368     zoneStrings = ures_getByKeyWithFallback(zoneStrings, gZoneStrings, zoneStrings, &tmpsts);
 369
 370     if (U_SUCCESS(tmpsts)) {
 371         const UChar *regionPattern = ures_getStringByKeyWithFallback(zoneStrings, gRegionFormatTag, NULL, &tmpsts);
 372         if (U_SUCCESS(tmpsts) && u_strlen(regionPattern) > 0) {
 373             rpat.setTo(regionPattern, -1);
 374         }
 375         tmpsts = U_ZERO_ERROR;
 376         const UChar *fallbackPattern = ures_getStringByKeyWithFallback(zoneStrings, gFallbackFormatTag, NULL, &tmpsts);
 377         if (U_SUCCESS(tmpsts) && u_strlen(fallbackPattern) > 0) {
 378             fpat.setTo(fallbackPattern, -1);
 379         }
 380     }
 381     ures_close(zoneStrings);
 382
 383     fRegionFormat.applyPatternMinMaxArguments(rpat, 1, 1, status);
 384     fFallbackFormat.applyPatternMinMaxArguments(fpat, 2, 2, status);
 385     if (U_FAILURE(status)) {
 386         cleanup();
 387         return;
 388     }
 389
 390     // locale display names
 391     fLocaleDisplayNames = LocaleDisplayNames::createInstance(locale);
 392
 393     // hash table for names - no key/value deleters
 394     fLocationNamesMap = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status);
 395     if (U_FAILURE(status)) {
 396         cleanup();
 397         return;
 398     }
 399
 400     fPartialLocationNamesMap = uhash_open(hashPartialLocationKey, comparePartialLocationKey, NULL, &status);
 401     if (U_FAILURE(status)) {
 402         cleanup();
 403         return;
 404     }
 405     uhash_setKeyDeleter(fPartialLocationNamesMap, uprv_free);
 406     // no value deleter
 407
 408     // target region
 409     const char* region = fLocale.getCountry();
 410     int32_t regionLen = uprv_strlen(region);
 411     if (regionLen == 0) {
 412         char loc[ULOC_FULLNAME_CAPACITY];
 413         uloc_addLikelySubtags(fLocale.getName(), loc, sizeof(loc), &status);
 414
 415         regionLen = uloc_getCountry(loc, fTargetRegion, sizeof(fTargetRegion), &status);
 416         if (U_SUCCESS(status)) {
 417             fTargetRegion[regionLen] = 0;
 418         } else {
 419             cleanup();
 420             return;
 421         }
 422     } else if (regionLen < (int32_t)sizeof(fTargetRegion)) {
 423         uprv_strcpy(fTargetRegion, region);
 424     } else {
 425         fTargetRegion[0] = 0;
 426     }
 427
 428     // preload generic names for the default zone
 429     TimeZone *tz = TimeZone::createDefault();
 430     const UChar *tzID = ZoneMeta::getCanonicalCLDRID(*tz);
 431     if (tzID != NULL) {
 432         loadStrings(UnicodeString(TRUE, tzID, -1));
 433     }
 434     delete tz;
 435 }
 436
 437 void
 438 TZGNCore::cleanup() {
 439     if (fLocaleDisplayNames != NULL) {
 440         delete fLocaleDisplayNames;
 441     }
 442     if (fTimeZoneNames != NULL) {
 443         delete fTimeZoneNames;
 444     }
 445
 446     uhash_close(fLocationNamesMap);
 447     uhash_close(fPartialLocationNamesMap);
 448 }
 449
 450
 451 UnicodeString&
 452 TZGNCore::getDisplayName(const TimeZone& tz, UTimeZoneGenericNameType type, UDate date, UnicodeString& name) const {
 453     name.setToBogus();
 454     switch (type) {
 455     case UTZGNM_LOCATION:
 456         {
 457             const UChar* tzCanonicalID = ZoneMeta::getCanonicalCLDRID(tz);
 458             if (tzCanonicalID != NULL) {
 459                 getGenericLocationName(UnicodeString(TRUE, tzCanonicalID, -1), name);
 460             }
 461         }
 462         break;
 463     case UTZGNM_LONG:
 464     case UTZGNM_SHORT:
 465         formatGenericNonLocationName(tz, type, date, name);
 466         if (name.isEmpty()) {
 467             const UChar* tzCanonicalID = ZoneMeta::getCanonicalCLDRID(tz);
 468             if (tzCanonicalID != NULL) {
 469                 getGenericLocationName(UnicodeString(TRUE, tzCanonicalID, -1), name);
 470             }
 471         }
 472         break;
 473     default:
 474         break;
 475     }
 476     return name;
 477 }
 478
 479 UnicodeString&
 480 TZGNCore::getGenericLocationName(const UnicodeString& tzCanonicalID, UnicodeString& name) const {
 481     if (tzCanonicalID.isEmpty()) {
 482         name.setToBogus();
 483         return name;
 484     }
 485
 486     const UChar *locname = NULL;
 487     TZGNCore *nonConstThis = const_cast<TZGNCore *>(this);
 488     umtx_lock(&gLock);
 489     {
 490         locname = nonConstThis->getGenericLocationName(tzCanonicalID);
 491     }
 492     umtx_unlock(&gLock);
 493
 494     if (locname == NULL) {
 495         name.setToBogus();
 496     } else {
 497         name.setTo(locname, u_strlen(locname));
 498     }
 499
 500     return name;
 501 }
 502
 503 /*
 504  * This method updates the cache and must be called with a lock
 505  */
 506 const UChar*
 507 TZGNCore::getGenericLocationName(const UnicodeString& tzCanonicalID) {
 508     U_ASSERT(!tzCanonicalID.isEmpty());
 509     if (tzCanonicalID.length() > ZID_KEY_MAX) {
 510         return NULL;
 511     }
 512
 513     UErrorCode status = U_ZERO_ERROR;
 514     UChar tzIDKey[ZID_KEY_MAX + 1];
 515     int32_t tzIDKeyLen = tzCanonicalID.extract(tzIDKey, ZID_KEY_MAX + 1, status);
 516     U_ASSERT(status == U_ZERO_ERROR);   // already checked length above
 517     tzIDKey[tzIDKeyLen] = 0;
 518
 519     const UChar *locname = (const UChar *)uhash_get(fLocationNamesMap, tzIDKey);
 520
 521     if (locname != NULL) {
 522         // gEmpty indicate the name is not available
 523         if (locname == gEmpty) {
 524             return NULL;
 525         }
 526         return locname;
 527     }
 528
 529     // Construct location name
 530     UnicodeString name;
 531     UnicodeString usCountryCode;
 532     UBool isPrimary = FALSE;
 533
 534     ZoneMeta::getCanonicalCountry(tzCanonicalID, usCountryCode, &isPrimary);
 535
 536     if (!usCountryCode.isEmpty()) {
 537         if (isPrimary) {
 538             // If this is the primary zone in the country, use the country name.
 539             char countryCode[ULOC_COUNTRY_CAPACITY];
 540             U_ASSERT(usCountryCode.length() < ULOC_COUNTRY_CAPACITY);
 541             int32_t ccLen = usCountryCode.extract(0, usCountryCode.length(), countryCode, sizeof(countryCode), US_INV);
 542             countryCode[ccLen] = 0;
 543
 544             UnicodeString country;
 545             fLocaleDisplayNames->regionDisplayName(countryCode, country);
 546             fRegionFormat.format(country, name, status);
 547         } else {
 548             // If this is not the primary zone in the country,
 549             // use the exemplar city name.
 550
 551             // getExemplarLocationName should retur non-empty string
 552             // if the time zone is associated with a region
 553
 554             UnicodeString city;
 555             fTimeZoneNames->getExemplarLocationName(tzCanonicalID, city);
 556             fRegionFormat.format(city, name, status);
 557         }
 558         if (U_FAILURE(status)) {
 559             return NULL;
 560         }
 561     }
 562
 563     locname = name.isEmpty() ? NULL : fStringPool.get(name, status);
 564     if (U_SUCCESS(status)) {
 565         // Cache the result
 566         const UChar* cacheID = ZoneMeta::findTimeZoneID(tzCanonicalID);
 567         U_ASSERT(cacheID != NULL);
 568         if (locname == NULL) {
 569             // gEmpty to indicate - no location name available
 570             uhash_put(fLocationNamesMap, (void *)cacheID, (void *)gEmpty, &status);
 571         } else {
 572             uhash_put(fLocationNamesMap, (void *)cacheID, (void *)locname, &status);
 573             if (U_FAILURE(status)) {
 574                 locname = NULL;
 575             } else {
 576                 // put the name info into the trie
 577                 GNameInfo *nameinfo = (ZNameInfo *)uprv_malloc(sizeof(GNameInfo));
 578                 if (nameinfo != NULL) {
 579                     nameinfo->type = UTZGNM_LOCATION;
 580                     nameinfo->tzID = cacheID;
 581                     fGNamesTrie.put(locname, nameinfo, status);
 582                 }
 583             }
 584         }
 585     }
 586
 587     return locname;
 588 }
 589
 590 UnicodeString&
 591 TZGNCore::formatGenericNonLocationName(const TimeZone& tz, UTimeZoneGenericNameType type, UDate date, UnicodeString& name) const {
 592     U_ASSERT(type == UTZGNM_LONG || type == UTZGNM_SHORT);
 593     name.setToBogus();
 594
 595     const UChar* uID = ZoneMeta::getCanonicalCLDRID(tz);
 596     if (uID == NULL) {
 597         return name;
 598     }
 599
 600     UnicodeString tzID(TRUE, uID, -1);
 601
 602     // Try to get a name from time zone first
 603     UTimeZoneNameType nameType = (type == UTZGNM_LONG) ? UTZNM_LONG_GENERIC : UTZNM_SHORT_GENERIC;
 604     fTimeZoneNames->getTimeZoneDisplayName(tzID, nameType, name);
 605
 606     if (!name.isEmpty()) {
 607         return name;
 608     }
 609
 610     // Try meta zone
 611     UChar mzIDBuf[32];
 612     UnicodeString mzID(mzIDBuf, 0, UPRV_LENGTHOF(mzIDBuf));
 613     fTimeZoneNames->getMetaZoneID(tzID, date, mzID);
 614     if (!mzID.isEmpty()) {
 615         UErrorCode status = U_ZERO_ERROR;
 616         UBool useStandard = FALSE;
 617         int32_t raw, sav;
 618         UChar tmpNameBuf[64];
 619
 620         tz.getOffset(date, FALSE, raw, sav, status);
 621         if (U_FAILURE(status)) {
 622             return name;
 623         }
 624
 625         if (sav == 0) {
 626             useStandard = TRUE;
 627
 628             TimeZone *tmptz = tz.clone();
 629             // Check if the zone actually uses daylight saving time around the time
 630             BasicTimeZone *btz = NULL;
 631             if (dynamic_cast<OlsonTimeZone *>(tmptz) != NULL
 632                 || dynamic_cast<SimpleTimeZone *>(tmptz) != NULL
 633                 || dynamic_cast<RuleBasedTimeZone *>(tmptz) != NULL
 634                 || dynamic_cast<VTimeZone *>(tmptz) != NULL) {
 635                 btz = (BasicTimeZone*)tmptz;
 636             }
 637
 638             if (btz != NULL) {
 639                 TimeZoneTransition before;
 640                 UBool beforTrs = btz->getPreviousTransition(date, TRUE, before);
 641                 if (beforTrs
 642                         && (date - before.getTime() < kDstCheckRange)
 643                         && before.getFrom()->getDSTSavings() != 0) {
 644                     useStandard = FALSE;
 645                 } else {
 646                     TimeZoneTransition after;
 647                     UBool afterTrs = btz->getNextTransition(date, FALSE, after);
 648                     if (afterTrs
 649                             && (after.getTime() - date < kDstCheckRange)
 650                             && after.getTo()->getDSTSavings() != 0) {
 651                         useStandard = FALSE;
 652                     }
 653                 }
 654             } else {
 655                 // If not BasicTimeZone... only if the instance is not an ICU's implementation.
 656                 // We may get a wrong answer in edge case, but it should practically work OK.
 657                 tmptz->getOffset(date - kDstCheckRange, FALSE, raw, sav, status);
 658                 if (sav != 0) {
 659                     useStandard = FALSE;
 660                 } else {
 661                     tmptz->getOffset(date + kDstCheckRange, FALSE, raw, sav, status);
 662                     if (sav != 0){
 663                         useStandard = FALSE;
 664                     }
 665                 }
 666                 if (U_FAILURE(status)) {
 667                     delete tmptz;
 668                     return name;
 669                 }
 670             }
 671             delete tmptz;
 672         }
 673         if (useStandard) {
 674             UTimeZoneNameType stdNameType = (nameType == UTZNM_LONG_GENERIC)
 675                 ? UTZNM_LONG_STANDARD : UTZNM_SHORT_STANDARD;
 676             UnicodeString stdName(tmpNameBuf, 0, UPRV_LENGTHOF(tmpNameBuf));
 677             fTimeZoneNames->getDisplayName(tzID, stdNameType, date, stdName);
 678             if (!stdName.isEmpty()) {
 679                 name.setTo(stdName);
 680
 681                 // TODO: revisit this issue later
 682                 // In CLDR, a same display name is used for both generic and standard
 683                 // for some meta zones in some locales.  This looks like a data bugs.
 684                 // For now, we check if the standard name is different from its generic
 685                 // name below.
 686                 UChar genNameBuf[64];
 687                 UnicodeString mzGenericName(genNameBuf, 0, UPRV_LENGTHOF(genNameBuf));
 688                 fTimeZoneNames->getMetaZoneDisplayName(mzID, nameType, mzGenericName);
 689                 if (stdName.caseCompare(mzGenericName, 0) == 0) {
 690                     name.setToBogus();
 691                 }
 692             }
 693         }
 694         if (name.isEmpty()) {
 695             // Get a name from meta zone
 696             UnicodeString mzName(tmpNameBuf, 0, UPRV_LENGTHOF(tmpNameBuf));
 697             fTimeZoneNames->getMetaZoneDisplayName(mzID, nameType, mzName);
 698             if (!mzName.isEmpty()) {
 699                 // Check if we need to use a partial location format.
 700                 // This check is done by comparing offset with the meta zone's
 701                 // golden zone at the given date.
 702                 UChar idBuf[32];
 703                 UnicodeString goldenID(idBuf, 0, UPRV_LENGTHOF(idBuf));
 704                 fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, goldenID);
 705                 if (!goldenID.isEmpty() && goldenID != tzID) {
 706                     TimeZone *goldenZone = TimeZone::createTimeZone(goldenID);
 707                     int32_t raw1, sav1;
 708
 709                     // Check offset in the golden zone with wall time.
 710                     // With getOffset(date, false, offsets1),
 711                     // you may get incorrect results because of time overlap at DST->STD
 712                     // transition.
 713                     goldenZone->getOffset(date + raw + sav, TRUE, raw1, sav1, status);
 714                     delete goldenZone;
 715                     if (U_SUCCESS(status)) {
 716                         if (raw != raw1 || sav != sav1) {
 717                             // Now we need to use a partial location format
 718                             getPartialLocationName(tzID, mzID, (nameType == UTZNM_LONG_GENERIC), mzName, name);
 719                         } else {
 720                             name.setTo(mzName);
 721                         }
 722                     }
 723                 } else {
 724                     name.setTo(mzName);
 725                 }
 726             }
 727         }
 728     }
 729     return name;
 730 }
 731
 732 UnicodeString&
 733 TZGNCore::getPartialLocationName(const UnicodeString& tzCanonicalID,
 734                         const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName,
 735                         UnicodeString& name) const {
 736     name.setToBogus();
 737     if (tzCanonicalID.isEmpty() || mzID.isEmpty() || mzDisplayName.isEmpty()) {
 738         return name;
 739     }
 740
 741     const UChar *uplname = NULL;
 742     TZGNCore *nonConstThis = const_cast<TZGNCore *>(this);
 743     umtx_lock(&gLock);
 744     {
 745         uplname = nonConstThis->getPartialLocationName(tzCanonicalID, mzID, isLong, mzDisplayName);
 746     }
 747     umtx_unlock(&gLock);
 748
 749     if (uplname == NULL) {
 750         name.setToBogus();
 751     } else {
 752         name.setTo(TRUE, uplname, -1);
 753     }
 754     return name;
 755 }
 756
 757 /*
 758  * This method updates the cache and must be called with a lock
 759  */
 760 const UChar*
 761 TZGNCore::getPartialLocationName(const UnicodeString& tzCanonicalID,
 762                         const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName) {
 763     U_ASSERT(!tzCanonicalID.isEmpty());
 764     U_ASSERT(!mzID.isEmpty());
 765     U_ASSERT(!mzDisplayName.isEmpty());
 766
 767     PartialLocationKey key;
 768     key.tzID = ZoneMeta::findTimeZoneID(tzCanonicalID);
 769     key.mzID = ZoneMeta::findMetaZoneID(mzID);
 770     key.isLong = isLong;
 771     U_ASSERT(key.tzID != NULL && key.mzID != NULL);
 772
 773     const UChar* uplname = (const UChar*)uhash_get(fPartialLocationNamesMap, (void *)&key);
 774     if (uplname != NULL) {
 775         return uplname;
 776     }
 777
 778     UnicodeString location;
 779     UnicodeString usCountryCode;
 780     ZoneMeta::getCanonicalCountry(tzCanonicalID, usCountryCode);
 781     if (!usCountryCode.isEmpty()) {
 782         char countryCode[ULOC_COUNTRY_CAPACITY];
 783         U_ASSERT(usCountryCode.length() < ULOC_COUNTRY_CAPACITY);
 784         int32_t ccLen = usCountryCode.extract(0, usCountryCode.length(), countryCode, sizeof(countryCode), US_INV);
 785         countryCode[ccLen] = 0;
 786
 787         UnicodeString regionalGolden;
 788         fTimeZoneNames->getReferenceZoneID(mzID, countryCode, regionalGolden);
 789         if (tzCanonicalID == regionalGolden) {
 790             // Use country name
 791             fLocaleDisplayNames->regionDisplayName(countryCode, location);
 792         } else {
 793             // Otherwise, use exemplar city name
 794             fTimeZoneNames->getExemplarLocationName(tzCanonicalID, location);
 795         }
 796     } else {
 797         fTimeZoneNames->getExemplarLocationName(tzCanonicalID, location);
 798         if (location.isEmpty()) {
 799             // This could happen when the time zone is not associated with a country,
 800             // and its ID is not hierarchical, for example, CST6CDT.
 801             // We use the canonical ID itself as the location for this case.
 802             location.setTo(tzCanonicalID);
 803         }
 804     }
 805
 806     UErrorCode status = U_ZERO_ERROR;
 807     UnicodeString name;
 808     fFallbackFormat.format(location, mzDisplayName, name, status);
 809     if (U_FAILURE(status)) {
 810         return NULL;
 811     }
 812
 813     uplname = fStringPool.get(name, status);
 814     if (U_SUCCESS(status)) {
 815         // Add the name to cache
 816         PartialLocationKey* cacheKey = (PartialLocationKey *)uprv_malloc(sizeof(PartialLocationKey));
 817         if (cacheKey != NULL) {
 818             cacheKey->tzID = key.tzID;
 819             cacheKey->mzID = key.mzID;
 820             cacheKey->isLong = key.isLong;
 821             uhash_put(fPartialLocationNamesMap, (void *)cacheKey, (void *)uplname, &status);
 822             if (U_FAILURE(status)) {
 823                 uprv_free(cacheKey);
 824             } else {
 825                 // put the name to the local trie as well
 826                 GNameInfo *nameinfo = (ZNameInfo *)uprv_malloc(sizeof(GNameInfo));
 827                 if (nameinfo != NULL) {
 828                     nameinfo->type = isLong ? UTZGNM_LONG : UTZGNM_SHORT;
 829                     nameinfo->tzID = key.tzID;
 830                     fGNamesTrie.put(uplname, nameinfo, status);
 831                 }
 832             }
 833         }
 834     }
 835     return uplname;
 836 }
 837
 838 /*
 839  * This method updates the cache and must be called with a lock,
 840  * except initializer.
 841  */
 842 void
 843 TZGNCore::loadStrings(const UnicodeString& tzCanonicalID) {
 844     // load the generic location name
 845     getGenericLocationName(tzCanonicalID);
 846
 847     // partial location names
 848     UErrorCode status = U_ZERO_ERROR;
 849
 850     const UnicodeString *mzID;
 851     UnicodeString goldenID;
 852     UnicodeString mzGenName;
 853     UTimeZoneNameType genNonLocTypes[] = {
 854         UTZNM_LONG_GENERIC, UTZNM_SHORT_GENERIC,
 855         UTZNM_UNKNOWN /*terminator*/
 856     };
 857
 858     StringEnumeration *mzIDs = fTimeZoneNames->getAvailableMetaZoneIDs(tzCanonicalID, status);
 859     while ((mzID = mzIDs->snext(status))) {
 860         if (U_FAILURE(status)) {
 861             break;
 862         }
 863         // if this time zone is not the golden zone of the meta zone,
 864         // partial location name (such as "PT (Los Angeles)") might be
 865         // available.
 866         fTimeZoneNames->getReferenceZoneID(*mzID, fTargetRegion, goldenID);
 867         if (tzCanonicalID != goldenID) {
 868             for (int32_t i = 0; genNonLocTypes[i] != UTZNM_UNKNOWN; i++) {
 869                 fTimeZoneNames->getMetaZoneDisplayName(*mzID, genNonLocTypes[i], mzGenName);
 870                 if (!mzGenName.isEmpty()) {
 871                     // getPartialLocationName formats a name and put it into the trie
 872                     getPartialLocationName(tzCanonicalID, *mzID,
 873                         (genNonLocTypes[i] == UTZNM_LONG_GENERIC), mzGenName);
 874                 }
 875             }
 876         }
 877     }
 878     if (mzIDs != NULL) {
 879         delete mzIDs;
 880     }
 881 }
 882
 883 int32_t
 884 TZGNCore::findBestMatch(const UnicodeString& text, int32_t start, uint32_t types,
 885         UnicodeString& tzID, UTimeZoneFormatTimeType& timeType, UErrorCode& status) const {
 886     timeType = UTZFMT_TIME_TYPE_UNKNOWN;
 887     tzID.setToBogus();
 888
 889     if (U_FAILURE(status)) {
 890         return 0;
 891     }
 892
 893     // Find matches in the TimeZoneNames first
 894     TimeZoneNames::MatchInfoCollection *tznamesMatches = findTimeZoneNames(text, start, types, status);
 895     if (U_FAILURE(status)) {
 896         return 0;
 897     }
 898
 899     int32_t bestMatchLen = 0;
 900     UTimeZoneFormatTimeType bestMatchTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
 901     UnicodeString bestMatchTzID;
 902     // UBool isLongStandard = FALSE;   // workaround - see the comments below
 903     UBool isStandard = FALSE;       // TODO: Temporary hack (on hack) for short standard name/location name conflict (found in zh_Hant), should be removed after CLDR 21m1 integration
 904
 905     if (tznamesMatches != NULL) {
 906         UnicodeString mzID;
 907         for (int32_t i = 0; i < tznamesMatches->size(); i++) {
 908             int32_t len = tznamesMatches->getMatchLengthAt(i);
 909             if (len > bestMatchLen) {
 910                 bestMatchLen = len;
 911                 if (!tznamesMatches->getTimeZoneIDAt(i, bestMatchTzID)) {
 912                     // name for a meta zone
 913                     if (tznamesMatches->getMetaZoneIDAt(i, mzID)) {
 914                         fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, bestMatchTzID);
 915                     }
 916                 }
 917                 UTimeZoneNameType nameType = tznamesMatches->getNameTypeAt(i);
 918                 if (U_FAILURE(status)) {
 919                     break;
 920                 }
 921                 switch (nameType) {
 922                 case UTZNM_LONG_STANDARD:
 923                     // isLongStandard = TRUE;
 924                 case UTZNM_SHORT_STANDARD:  // this one is never used for generic, but just in case
 925                     isStandard = TRUE;      // TODO: Remove this later, see the comments above.
 926                     bestMatchTimeType = UTZFMT_TIME_TYPE_STANDARD;
 927                     break;
 928                 case UTZNM_LONG_DAYLIGHT:
 929                 case UTZNM_SHORT_DAYLIGHT: // this one is never used for generic, but just in case
 930                     bestMatchTimeType = UTZFMT_TIME_TYPE_DAYLIGHT;
 931                     break;
 932                 default:
 933                     bestMatchTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
 934                 }
 935             }
 936         }
 937         delete tznamesMatches;
 938         if (U_FAILURE(status)) {
 939             return 0;
 940         }
 941
 942         if (bestMatchLen == (text.length() - start)) {
 943             // Full match
 944
 945             //tzID.setTo(bestMatchTzID);
 946             //timeType = bestMatchTimeType;
 947             //return bestMatchLen;
 948
 949             // TODO Some time zone uses a same name for the long standard name
 950             // and the location name. When the match is a long standard name,
 951             // then we need to check if the name is same with the location name.
 952             // This is probably a data error or a design bug.
 953 /*
 954             if (!isLongStandard) {
 955                 tzID.setTo(bestMatchTzID);
 956                 timeType = bestMatchTimeType;
 957                 return bestMatchLen;
 958             }
 959 */
 960             // TODO The deprecation of commonlyUsed flag introduced the name
 961             // conflict not only for long standard names, but short standard names too.
 962             // These short names (found in zh_Hant) should be gone once we clean
 963             // up CLDR time zone display name data. Once the short name conflict
 964             // problem (with location name) is resolved, we should change the condition
 965             // below back to the original one above. -Yoshito (2011-09-14)
 966             if (!isStandard) {
 967                 tzID.setTo(bestMatchTzID);
 968                 timeType = bestMatchTimeType;
 969                 return bestMatchLen;
 970             }
 971         }
 972     }
 973
 974     // Find matches in the local trie
 975     TimeZoneGenericNameMatchInfo *localMatches = findLocal(text, start, types, status);
 976     if (U_FAILURE(status)) {
 977         return 0;
 978     }
 979     if (localMatches != NULL) {
 980         for (int32_t i = 0; i < localMatches->size(); i++) {
 981             int32_t len = localMatches->getMatchLength(i);
 982
 983             // TODO See the above TODO. We use len >= bestMatchLen
 984             // because of the long standard/location name collision
 985             // problem. If it is also a location name, carrying
 986             // timeType = UTZFMT_TIME_TYPE_STANDARD will cause a
 987             // problem in SimpleDateFormat
 988             if (len >= bestMatchLen) {
 989                 bestMatchLen = localMatches->getMatchLength(i);
 990                 bestMatchTimeType = UTZFMT_TIME_TYPE_UNKNOWN;   // because generic
 991                 localMatches->getTimeZoneID(i, bestMatchTzID);
 992             }
 993         }
 994         delete localMatches;
 995     }
 996
 997     if (bestMatchLen > 0) {
 998         timeType = bestMatchTimeType;
 999         tzID.setTo(bestMatchTzID);
1000     }
1001     return bestMatchLen;
1002 }
1003
1004 TimeZoneGenericNameMatchInfo*
1005 TZGNCore::findLocal(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const {
1006     GNameSearchHandler handler(types);
1007
1008     TZGNCore *nonConstThis = const_cast<TZGNCore *>(this);
1009
1010     umtx_lock(&gLock);
1011     {
1012         fGNamesTrie.search(text, start, (TextTrieMapSearchResultHandler *)&handler, status);
1013     }
1014     umtx_unlock(&gLock);
1015
1016     if (U_FAILURE(status)) {
1017         return NULL;
1018     }
1019
1020     TimeZoneGenericNameMatchInfo *gmatchInfo = NULL;
1021
1022     int32_t maxLen = 0;
1023     UVector *results = handler.getMatches(maxLen);
1024     if (results != NULL && ((maxLen == (text.length() - start)) || fGNamesTrieFullyLoaded)) {
1025         // perfect match
1026         gmatchInfo = new TimeZoneGenericNameMatchInfo(results);
1027         if (gmatchInfo == NULL) {
1028             status = U_MEMORY_ALLOCATION_ERROR;
1029             delete results;
1030             return NULL;
1031         }
1032         return gmatchInfo;
1033     }
1034
1035     if (results != NULL) {
1036         delete results;
1037     }
1038
1039     // All names are not yet loaded into the local trie.
1040     // Load all available names into the trie. This could be very heavy.
1041     umtx_lock(&gLock);
1042     {
1043         if (!fGNamesTrieFullyLoaded) {
1044             StringEnumeration *tzIDs = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL, NULL, NULL, status);
1045             if (U_SUCCESS(status)) {
1046                 const UnicodeString *tzID;
1047                 while ((tzID = tzIDs->snext(status))) {
1048                     if (U_FAILURE(status)) {
1049                         break;
1050                     }
1051                     nonConstThis->loadStrings(*tzID);
1052                 }
1053             }
1054             if (tzIDs != NULL) {
1055                 delete tzIDs;
1056             }
1057
1058             if (U_SUCCESS(status)) {
1059                 nonConstThis->fGNamesTrieFullyLoaded = TRUE;
1060             }
1061         }
1062     }
1063     umtx_unlock(&gLock);
1064
1065     if (U_FAILURE(status)) {
1066         return NULL;
1067     }
1068
1069     umtx_lock(&gLock);
1070     {
1071         // now try it again
1072         fGNamesTrie.search(text, start, (TextTrieMapSearchResultHandler *)&handler, status);
1073     }
1074     umtx_unlock(&gLock);
1075
1076     results = handler.getMatches(maxLen);
1077     if (results != NULL && maxLen > 0) {
1078         gmatchInfo = new TimeZoneGenericNameMatchInfo(results);
1079         if (gmatchInfo == NULL) {
1080             status = U_MEMORY_ALLOCATION_ERROR;
1081             delete results;
1082             return NULL;
1083         }
1084     }
1085
1086     return gmatchInfo;
1087 }
1088
1089 TimeZoneNames::MatchInfoCollection*
1090 TZGNCore::findTimeZoneNames(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const {
1091     // Check if the target name typs is really in the TimeZoneNames
1092     uint32_t nameTypes = 0;
1093     if (types & UTZGNM_LONG) {
1094         nameTypes |= (UTZNM_LONG_GENERIC | UTZNM_LONG_STANDARD);
1095     }
1096     if (types & UTZGNM_SHORT) {
1097         nameTypes |= (UTZNM_SHORT_GENERIC | UTZNM_SHORT_STANDARD);
1098     }
1099
1100     if (types) {
1101         // Find matches in the TimeZoneNames
1102         return fTimeZoneNames->find(text, start, nameTypes, status);
1103     }
1104
1105     return NULL;
1106 }
1107
1108 typedef struct TZGNCoreRef {
1109     TZGNCore*       obj;
1110     int32_t         refCount;
1111     double          lastAccess;
1112 } TZGNCoreRef;
1113
1114 // TZGNCore object cache handling
1115 static UMutex gTZGNLock = U_MUTEX_INITIALIZER;
1116 static UHashtable *gTZGNCoreCache = NULL;
1117 static UBool gTZGNCoreCacheInitialized = FALSE;
1118
1119 // Access count - incremented every time up to SWEEP_INTERVAL,
1120 // then reset to 0
1121 static int32_t gAccessCount = 0;
1122
1123 // Interval for calling the cache sweep function - every 100 times
1124 #define SWEEP_INTERVAL 100
1125
1126 // Cache expiration in millisecond. When a cached entry is no
1127 // longer referenced and exceeding this threshold since last
1128 // access time, then the cache entry will be deleted by the sweep
1129 // function. For now, 3 minutes.
1130 #define CACHE_EXPIRATION 180000.0
1131
1132 U_CDECL_BEGIN
1133 /**
1134  * Cleanup callback func
1135  */
1136 static UBool U_CALLCONV tzgnCore_cleanup(void)
1137 {
1138     if (gTZGNCoreCache != NULL) {
1139         uhash_close(gTZGNCoreCache);
1140         gTZGNCoreCache = NULL;
1141     }
1142     gTZGNCoreCacheInitialized = FALSE;
1143     return TRUE;
1144 }
1145
1146 /**
1147  * Deleter for TZGNCoreRef
1148  */
1149 static void U_CALLCONV
1150 deleteTZGNCoreRef(void *obj) {
1151     icu::TZGNCoreRef *entry = (icu::TZGNCoreRef*)obj;
1152     delete (icu::TZGNCore*) entry->obj;
1153     uprv_free(entry);
1154 }
1155 U_CDECL_END
1156
1157 /**
1158  * Function used for removing unreferrenced cache entries exceeding
1159  * the expiration time. This function must be called with in the mutex
1160  * block.
1161  */
1162 static void sweepCache() {
1163     int32_t pos = UHASH_FIRST;
1164     const UHashElement* elem;
1165     double now = (double)uprv_getUTCtime();
1166
1167     while ((elem = uhash_nextElement(gTZGNCoreCache, &pos))) {
1168         TZGNCoreRef *entry = (TZGNCoreRef *)elem->value.pointer;
1169         if (entry->refCount <= 0 && (now - entry->lastAccess) > CACHE_EXPIRATION) {
1170             // delete this entry
1171             uhash_removeElement(gTZGNCoreCache, elem);
1172         }
1173     }
1174 }
1175
1176 TimeZoneGenericNames::TimeZoneGenericNames()
1177 : fRef(0) {
1178 }
1179
1180 TimeZoneGenericNames::~TimeZoneGenericNames() {
1181     umtx_lock(&gTZGNLock);
1182     {
1183         U_ASSERT(fRef->refCount > 0);
1184         // Just decrement the reference count
1185         fRef->refCount--;
1186     }
1187     umtx_unlock(&gTZGNLock);
1188 }
1189
1190 TimeZoneGenericNames*
1191 TimeZoneGenericNames::createInstance(const Locale& locale, UErrorCode& status) {
1192     if (U_FAILURE(status)) {
1193         return NULL;
1194     }
1195     TimeZoneGenericNames* instance = new TimeZoneGenericNames();
1196     if (instance == NULL) {
1197         status = U_MEMORY_ALLOCATION_ERROR;
1198         return NULL;
1199     }
1200
1201     TZGNCoreRef *cacheEntry = NULL;
1202     {
1203         Mutex lock(&gTZGNLock);
1204
1205         if (!gTZGNCoreCacheInitialized) {
1206             // Create empty hashtable
1207             gTZGNCoreCache = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status);
1208             if (U_SUCCESS(status)) {
1209                 uhash_setKeyDeleter(gTZGNCoreCache, uprv_free);
1210                 uhash_setValueDeleter(gTZGNCoreCache, deleteTZGNCoreRef);
1211                 gTZGNCoreCacheInitialized = TRUE;
1212                 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONEGENERICNAMES, tzgnCore_cleanup);
1213             }
1214         }
1215         if (U_FAILURE(status)) {
1216             return NULL;
1217         }
1218
1219         // Check the cache, if not available, create new one and cache
1220         const char *key = locale.getName();
1221         cacheEntry = (TZGNCoreRef *)uhash_get(gTZGNCoreCache, key);
1222         if (cacheEntry == NULL) {
1223             TZGNCore *tzgnCore = NULL;
1224             char *newKey = NULL;
1225
1226             tzgnCore = new TZGNCore(locale, status);
1227             if (tzgnCore == NULL) {
1228                 status = U_MEMORY_ALLOCATION_ERROR;
1229             }
1230             if (U_SUCCESS(status)) {
1231                 newKey = (char *)uprv_malloc(uprv_strlen(key) + 1);
1232                 if (newKey == NULL) {
1233                     status = U_MEMORY_ALLOCATION_ERROR;
1234                 } else {
1235                     uprv_strcpy(newKey, key);
1236                 }
1237             }
1238             if (U_SUCCESS(status)) {
1239                 cacheEntry = (TZGNCoreRef *)uprv_malloc(sizeof(TZGNCoreRef));
1240                 if (cacheEntry == NULL) {
1241                     status = U_MEMORY_ALLOCATION_ERROR;
1242                 } else {
1243                     cacheEntry->obj = tzgnCore;
1244                     cacheEntry->refCount = 1;
1245                     cacheEntry->lastAccess = (double)uprv_getUTCtime();
1246
1247                     uhash_put(gTZGNCoreCache, newKey, cacheEntry, &status);
1248                 }
1249             }
1250             if (U_FAILURE(status)) {
1251                 if (tzgnCore != NULL) {
1252                     delete tzgnCore;
1253                 }
1254                 if (newKey != NULL) {
1255                     uprv_free(newKey);
1256                 }
1257                 if (cacheEntry != NULL) {
1258                     uprv_free(cacheEntry);
1259                 }
1260                 cacheEntry = NULL;
1261             }
1262         } else {
1263             // Update the reference count
1264             cacheEntry->refCount++;
1265             cacheEntry->lastAccess = (double)uprv_getUTCtime();
1266         }
1267         gAccessCount++;
1268         if (gAccessCount >= SWEEP_INTERVAL) {
1269             // sweep
1270             sweepCache();
1271             gAccessCount = 0;
1272         }
1273     }  // End of mutex locked block
1274
1275     if (cacheEntry == NULL) {
1276         delete instance;
1277         return NULL;
1278     }
1279
1280     instance->fRef = cacheEntry;
1281     return instance;
1282 }
1283
1284 UBool
1285 TimeZoneGenericNames::operator==(const TimeZoneGenericNames& other) const {
1286     // Just compare if the other object also use the same
1287     // ref entry
1288     return fRef == other.fRef;
1289 }
1290
1291 TimeZoneGenericNames*
1292 TimeZoneGenericNames::clone() const {
1293     TimeZoneGenericNames* other = new TimeZoneGenericNames();
1294     if (other) {
1295         umtx_lock(&gTZGNLock);
1296         {
1297             // Just increments the reference count
1298             fRef->refCount++;
1299             other->fRef = fRef;
1300         }
1301         umtx_unlock(&gTZGNLock);
1302     }
1303     return other;
1304 }
1305
1306 UnicodeString&
1307 TimeZoneGenericNames::getDisplayName(const TimeZone& tz, UTimeZoneGenericNameType type,
1308                         UDate date, UnicodeString& name) const {
1309     return fRef->obj->getDisplayName(tz, type, date, name);
1310 }
1311
1312 UnicodeString&
1313 TimeZoneGenericNames::getGenericLocationName(const UnicodeString& tzCanonicalID, UnicodeString& name) const {
1314     return fRef->obj->getGenericLocationName(tzCanonicalID, name);
1315 }
1316
1317 int32_t
1318 TimeZoneGenericNames::findBestMatch(const UnicodeString& text, int32_t start, uint32_t types,
1319         UnicodeString& tzID, UTimeZoneFormatTimeType& timeType, UErrorCode& status) const {
1320     return fRef->obj->findBestMatch(text, start, types, tzID, timeType, status);
1321 }
1322
1323 U_NAMESPACE_END
1324 #endif