icuSources/i18n/tzgnames.cpp

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