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