icuSources/i18n/tznames.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2011-2015, 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 "unicode/locid.h"
  13 #include "unicode/tznames.h"
  14 #include "unicode/uenum.h"
  15 #include "cmemory.h"
  16 #include "cstring.h"
  17 #include "mutex.h"
  18 #include "putilimp.h"
  19 #include "tznames_impl.h"
  20 #include "uassert.h"
  21 #include "ucln_in.h"
  22 #include "uhash.h"
  23 #include "umutex.h"
  24 #include "uvector.h"
  25
  26
  27 U_NAMESPACE_BEGIN
  28
  29 // TimeZoneNames object cache handling
  30 static UMutex gTimeZoneNamesLock = U_MUTEX_INITIALIZER;
  31 static UHashtable *gTimeZoneNamesCache = NULL;
  32 static UBool gTimeZoneNamesCacheInitialized = FALSE;
  33
  34 // Access count - incremented every time up to SWEEP_INTERVAL,
  35 // then reset to 0
  36 static int32_t gAccessCount = 0;
  37
  38 // Interval for calling the cache sweep function - every 100 times
  39 #define SWEEP_INTERVAL 100
  40
  41 // Cache expiration in millisecond. When a cached entry is no
  42 // longer referenced and exceeding this threshold since last
  43 // access time, then the cache entry will be deleted by the sweep
  44 // function. For now, 3 minutes.
  45 #define CACHE_EXPIRATION 180000.0
  46
  47 typedef struct TimeZoneNamesCacheEntry {
  48     TimeZoneNames*  names;
  49     int32_t         refCount;
  50     double          lastAccess;
  51 } TimeZoneNamesCacheEntry;
  52
  53 U_CDECL_BEGIN
  54 /**
  55  * Cleanup callback func
  56  */
  57 static UBool U_CALLCONV timeZoneNames_cleanup(void)
  58 {
  59     if (gTimeZoneNamesCache != NULL) {
  60         uhash_close(gTimeZoneNamesCache);
  61         gTimeZoneNamesCache = NULL;
  62     }
  63     gTimeZoneNamesCacheInitialized = FALSE;
  64     return TRUE;
  65 }
  66
  67 /**
  68  * Deleter for TimeZoneNamesCacheEntry
  69  */
  70 static void U_CALLCONV
  71 deleteTimeZoneNamesCacheEntry(void *obj) {
  72     icu::TimeZoneNamesCacheEntry *entry = (icu::TimeZoneNamesCacheEntry*)obj;
  73     delete (icu::TimeZoneNamesImpl*) entry->names;
  74     uprv_free(entry);
  75 }
  76 U_CDECL_END
  77
  78 /**
  79  * Function used for removing unreferrenced cache entries exceeding
  80  * the expiration time. This function must be called with in the mutex
  81  * block.
  82  */
  83 static void sweepCache() {
  84     int32_t pos = UHASH_FIRST;
  85     const UHashElement* elem;
  86     double now = (double)uprv_getUTCtime();
  87
  88     while ((elem = uhash_nextElement(gTimeZoneNamesCache, &pos))) {
  89         TimeZoneNamesCacheEntry *entry = (TimeZoneNamesCacheEntry *)elem->value.pointer;
  90         if (entry->refCount <= 0 && (now - entry->lastAccess) > CACHE_EXPIRATION) {
  91             // delete this entry
  92             uhash_removeElement(gTimeZoneNamesCache, elem);
  93         }
  94     }
  95 }
  96
  97 // ---------------------------------------------------
  98 // TimeZoneNamesDelegate
  99 // ---------------------------------------------------
 100 class TimeZoneNamesDelegate : public TimeZoneNames {
 101 public:
 102     TimeZoneNamesDelegate(const Locale& locale, UErrorCode& status);
 103     virtual ~TimeZoneNamesDelegate();
 104
 105     virtual UBool operator==(const TimeZoneNames& other) const;
 106     virtual UBool operator!=(const TimeZoneNames& other) const {return !operator==(other);};
 107     virtual TimeZoneNames* clone() const;
 108
 109     StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const;
 110     StringEnumeration* getAvailableMetaZoneIDs(const UnicodeString& tzID, UErrorCode& status) const;
 111     UnicodeString& getMetaZoneID(const UnicodeString& tzID, UDate date, UnicodeString& mzID) const;
 112     UnicodeString& getReferenceZoneID(const UnicodeString& mzID, const char* region, UnicodeString& tzID) const;
 113
 114     UnicodeString& getMetaZoneDisplayName(const UnicodeString& mzID, UTimeZoneNameType type, UnicodeString& name) const;
 115     UnicodeString& getTimeZoneDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UnicodeString& name) const;
 116
 117     UnicodeString& getExemplarLocationName(const UnicodeString& tzID, UnicodeString& name) const;
 118
 119     MatchInfoCollection* find(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const;
 120 private:
 121     TimeZoneNamesDelegate();
 122     TimeZoneNamesCacheEntry*    fTZnamesCacheEntry;
 123 };
 124
 125 TimeZoneNamesDelegate::TimeZoneNamesDelegate()
 126 : fTZnamesCacheEntry(0) {
 127 }
 128
 129 TimeZoneNamesDelegate::TimeZoneNamesDelegate(const Locale& locale, UErrorCode& status) {
 130     Mutex lock(&gTimeZoneNamesLock);
 131     if (!gTimeZoneNamesCacheInitialized) {
 132         // Create empty hashtable if it is not already initialized.
 133         gTimeZoneNamesCache = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status);
 134         if (U_SUCCESS(status)) {
 135             uhash_setKeyDeleter(gTimeZoneNamesCache, uprv_free);
 136             uhash_setValueDeleter(gTimeZoneNamesCache, deleteTimeZoneNamesCacheEntry);
 137             gTimeZoneNamesCacheInitialized = TRUE;
 138             ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONENAMES, timeZoneNames_cleanup);
 139         }
 140     }
 141
 142     if (U_FAILURE(status)) {
 143         return;
 144     }
 145
 146     // Check the cache, if not available, create new one and cache
 147     TimeZoneNamesCacheEntry *cacheEntry = NULL;
 148
 149     const char *key = locale.getName();
 150     cacheEntry = (TimeZoneNamesCacheEntry *)uhash_get(gTimeZoneNamesCache, key);
 151     if (cacheEntry == NULL) {
 152         TimeZoneNames *tznames = NULL;
 153         char *newKey = NULL;
 154
 155         tznames = new TimeZoneNamesImpl(locale, status);
 156         if (tznames == NULL) {
 157             status = U_MEMORY_ALLOCATION_ERROR;
 158         }
 159         if (U_SUCCESS(status)) {
 160             newKey = (char *)uprv_malloc(uprv_strlen(key) + 1);
 161             if (newKey == NULL) {
 162                 status = U_MEMORY_ALLOCATION_ERROR;
 163             } else {
 164                 uprv_strcpy(newKey, key);
 165             }
 166         }
 167         if (U_SUCCESS(status)) {
 168             cacheEntry = (TimeZoneNamesCacheEntry *)uprv_malloc(sizeof(TimeZoneNamesCacheEntry));
 169             if (cacheEntry == NULL) {
 170                 status = U_MEMORY_ALLOCATION_ERROR;
 171             } else {
 172                 cacheEntry->names = tznames;
 173                 cacheEntry->refCount = 1;
 174                 cacheEntry->lastAccess = (double)uprv_getUTCtime();
 175
 176                 uhash_put(gTimeZoneNamesCache, newKey, cacheEntry, &status);
 177             }
 178         }
 179         if (U_FAILURE(status)) {
 180             if (tznames != NULL) {
 181                 delete tznames;
 182             }
 183             if (newKey != NULL) {
 184                 uprv_free(newKey);
 185             }
 186             if (cacheEntry != NULL) {
 187                 uprv_free(cacheEntry);
 188             }
 189             cacheEntry = NULL;
 190         }
 191     } else {
 192         // Update the reference count
 193         cacheEntry->refCount++;
 194         cacheEntry->lastAccess = (double)uprv_getUTCtime();
 195     }
 196     gAccessCount++;
 197     if (gAccessCount >= SWEEP_INTERVAL) {
 198         // sweep
 199         sweepCache();
 200         gAccessCount = 0;
 201     }
 202     fTZnamesCacheEntry = cacheEntry;
 203 }
 204
 205 TimeZoneNamesDelegate::~TimeZoneNamesDelegate() {
 206     umtx_lock(&gTimeZoneNamesLock);
 207     {
 208         if (fTZnamesCacheEntry) {
 209             U_ASSERT(fTZnamesCacheEntry->refCount > 0);
 210             // Just decrement the reference count
 211             fTZnamesCacheEntry->refCount--;
 212         }
 213     }
 214     umtx_unlock(&gTimeZoneNamesLock);
 215 }
 216
 217 UBool
 218 TimeZoneNamesDelegate::operator==(const TimeZoneNames& other) const {
 219     if (this == &other) {
 220         return TRUE;
 221     }
 222     // Just compare if the other object also use the same
 223     // cache entry
 224     const TimeZoneNamesDelegate* rhs = dynamic_cast<const TimeZoneNamesDelegate*>(&other);
 225     if (rhs) {
 226         return fTZnamesCacheEntry == rhs->fTZnamesCacheEntry;
 227     }
 228     return FALSE;
 229 }
 230
 231 TimeZoneNames*
 232 TimeZoneNamesDelegate::clone() const {
 233     TimeZoneNamesDelegate* other = new TimeZoneNamesDelegate();
 234     if (other != NULL) {
 235         umtx_lock(&gTimeZoneNamesLock);
 236         {
 237             // Just increment the reference count
 238             fTZnamesCacheEntry->refCount++;
 239             other->fTZnamesCacheEntry = fTZnamesCacheEntry;
 240         }
 241         umtx_unlock(&gTimeZoneNamesLock);
 242     }
 243     return other;
 244 }
 245
 246 StringEnumeration*
 247 TimeZoneNamesDelegate::getAvailableMetaZoneIDs(UErrorCode& status) const {
 248     return fTZnamesCacheEntry->names->getAvailableMetaZoneIDs(status);
 249 }
 250
 251 StringEnumeration*
 252 TimeZoneNamesDelegate::getAvailableMetaZoneIDs(const UnicodeString& tzID, UErrorCode& status) const {
 253     return fTZnamesCacheEntry->names->getAvailableMetaZoneIDs(tzID, status);
 254 }
 255
 256 UnicodeString&
 257 TimeZoneNamesDelegate::getMetaZoneID(const UnicodeString& tzID, UDate date, UnicodeString& mzID) const {
 258     return fTZnamesCacheEntry->names->getMetaZoneID(tzID, date, mzID);
 259 }
 260
 261 UnicodeString&
 262 TimeZoneNamesDelegate::getReferenceZoneID(const UnicodeString& mzID, const char* region, UnicodeString& tzID) const {
 263     return fTZnamesCacheEntry->names->getReferenceZoneID(mzID, region, tzID);
 264 }
 265
 266 UnicodeString&
 267 TimeZoneNamesDelegate::getMetaZoneDisplayName(const UnicodeString& mzID, UTimeZoneNameType type, UnicodeString& name) const {
 268     return fTZnamesCacheEntry->names->getMetaZoneDisplayName(mzID, type, name);
 269 }
 270
 271 UnicodeString&
 272 TimeZoneNamesDelegate::getTimeZoneDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UnicodeString& name) const {
 273     return fTZnamesCacheEntry->names->getTimeZoneDisplayName(tzID, type, name);
 274 }
 275
 276 UnicodeString&
 277 TimeZoneNamesDelegate::getExemplarLocationName(const UnicodeString& tzID, UnicodeString& name) const {
 278     return fTZnamesCacheEntry->names->getExemplarLocationName(tzID, name);
 279 }
 280
 281 TimeZoneNames::MatchInfoCollection*
 282 TimeZoneNamesDelegate::find(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const {
 283     return fTZnamesCacheEntry->names->find(text, start, types, status);
 284 }
 285
 286 // ---------------------------------------------------
 287 // TimeZoneNames base class
 288 // ---------------------------------------------------
 289 TimeZoneNames::~TimeZoneNames() {
 290 }
 291
 292 TimeZoneNames*
 293 TimeZoneNames::createInstance(const Locale& locale, UErrorCode& status) {
 294     TimeZoneNames *instance = NULL;
 295     if (U_SUCCESS(status)) {
 296         instance = new TimeZoneNamesDelegate(locale, status);
 297         if (instance == NULL && U_SUCCESS(status)) {
 298             status = U_MEMORY_ALLOCATION_ERROR;
 299         }
 300     }
 301     return instance;
 302 }
 303
 304 TimeZoneNames*
 305 TimeZoneNames::createTZDBInstance(const Locale& locale, UErrorCode& status) {
 306     TimeZoneNames *instance = NULL;
 307     if (U_SUCCESS(status)) {
 308         instance = new TZDBTimeZoneNames(locale);
 309         if (instance == NULL && U_SUCCESS(status)) {
 310             status = U_MEMORY_ALLOCATION_ERROR;
 311         }
 312     }
 313     return instance;
 314 }
 315
 316 UnicodeString&
 317 TimeZoneNames::getExemplarLocationName(const UnicodeString& tzID, UnicodeString& name) const {
 318     return TimeZoneNamesImpl::getDefaultExemplarLocationName(tzID, name);
 319 }
 320
 321 UnicodeString&
 322 TimeZoneNames::getDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UDate date, UnicodeString& name) const {
 323     getTimeZoneDisplayName(tzID, type, name);
 324     if (name.isEmpty()) {
 325         UChar mzIDBuf[32];
 326         UnicodeString mzID(mzIDBuf, 0, UPRV_LENGTHOF(mzIDBuf));
 327         getMetaZoneID(tzID, date, mzID);
 328         getMetaZoneDisplayName(mzID, type, name);
 329     }
 330     return name;
 331 }
 332
 333
 334 struct MatchInfo : UMemory {
 335     UTimeZoneNameType nameType;
 336     UnicodeString id;
 337     int32_t matchLength;
 338     UBool isTZID;
 339
 340     MatchInfo(UTimeZoneNameType nameType, int32_t matchLength, const UnicodeString* tzID, const UnicodeString* mzID) {
 341         this->nameType = nameType;
 342         this->matchLength = matchLength;
 343         if (tzID != NULL) {
 344             this->id.setTo(*tzID);
 345             this->isTZID = TRUE;
 346         } else {
 347             this->id.setTo(*mzID);
 348             this->isTZID = FALSE;
 349         }
 350     }
 351 };
 352
 353 U_CDECL_BEGIN
 354 static void U_CALLCONV
 355 deleteMatchInfo(void *obj) {
 356     delete static_cast<MatchInfo *>(obj);
 357 }
 358 U_CDECL_END
 359
 360 // ---------------------------------------------------
 361 // MatchInfoCollection class
 362 // ---------------------------------------------------
 363 TimeZoneNames::MatchInfoCollection::MatchInfoCollection()
 364 : fMatches(NULL) {
 365 }
 366
 367 TimeZoneNames::MatchInfoCollection::~MatchInfoCollection() {
 368     if (fMatches != NULL) {
 369         delete fMatches;
 370     }
 371 }
 372
 373 void
 374 TimeZoneNames::MatchInfoCollection::addZone(UTimeZoneNameType nameType, int32_t matchLength,
 375             const UnicodeString& tzID, UErrorCode& status) {
 376     if (U_FAILURE(status)) {
 377         return;
 378     }
 379     MatchInfo* matchInfo = new MatchInfo(nameType, matchLength, &tzID, NULL);
 380     if (matchInfo == NULL) {
 381         status = U_MEMORY_ALLOCATION_ERROR;
 382         return;
 383     }
 384     matches(status)->addElement(matchInfo, status);
 385     if (U_FAILURE(status)) {
 386         delete matchInfo;
 387     }
 388 }
 389
 390 void
 391 TimeZoneNames::MatchInfoCollection::addMetaZone(UTimeZoneNameType nameType, int32_t matchLength,
 392             const UnicodeString& mzID, UErrorCode& status) {
 393     if (U_FAILURE(status)) {
 394         return;
 395     }
 396     MatchInfo* matchInfo = new MatchInfo(nameType, matchLength, NULL, &mzID);
 397     if (matchInfo == NULL) {
 398         status = U_MEMORY_ALLOCATION_ERROR;
 399         return;
 400     }
 401     matches(status)->addElement(matchInfo, status);
 402     if (U_FAILURE(status)) {
 403         delete matchInfo;
 404     }
 405 }
 406
 407 int32_t
 408 TimeZoneNames::MatchInfoCollection::size() const {
 409     if (fMatches == NULL) {
 410         return 0;
 411     }
 412     return fMatches->size();
 413 }
 414
 415 UTimeZoneNameType
 416 TimeZoneNames::MatchInfoCollection::getNameTypeAt(int32_t idx) const {
 417     const MatchInfo* match = (const MatchInfo*)fMatches->elementAt(idx);
 418     if (match) {
 419         return match->nameType;
 420     }
 421     return UTZNM_UNKNOWN;
 422 }
 423
 424 int32_t
 425 TimeZoneNames::MatchInfoCollection::getMatchLengthAt(int32_t idx) const {
 426     const MatchInfo* match = (const MatchInfo*)fMatches->elementAt(idx);
 427     if (match) {
 428         return match->matchLength;
 429     }
 430     return 0;
 431 }
 432
 433 UBool
 434 TimeZoneNames::MatchInfoCollection::getTimeZoneIDAt(int32_t idx, UnicodeString& tzID) const {
 435     tzID.remove();
 436     const MatchInfo* match = (const MatchInfo*)fMatches->elementAt(idx);
 437     if (match && match->isTZID) {
 438         tzID.setTo(match->id);
 439         return TRUE;
 440     }
 441     return FALSE;
 442 }
 443
 444 UBool
 445 TimeZoneNames::MatchInfoCollection::getMetaZoneIDAt(int32_t idx, UnicodeString& mzID) const {
 446     mzID.remove();
 447     const MatchInfo* match = (const MatchInfo*)fMatches->elementAt(idx);
 448     if (match && !match->isTZID) {
 449         mzID.setTo(match->id);
 450         return TRUE;
 451     }
 452     return FALSE;
 453 }
 454
 455 UVector*
 456 TimeZoneNames::MatchInfoCollection::matches(UErrorCode& status) {
 457     if (U_FAILURE(status)) {
 458         return NULL;
 459     }
 460     if (fMatches != NULL) {
 461         return fMatches;
 462     }
 463     fMatches = new UVector(deleteMatchInfo, NULL, status);
 464     if (fMatches == NULL) {
 465         status = U_MEMORY_ALLOCATION_ERROR;
 466     } else if (U_FAILURE(status)) {
 467         delete fMatches;
 468         fMatches = NULL;
 469     }
 470     return fMatches;
 471 }
 472
 473
 474 U_NAMESPACE_END
 475 #endif