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