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