diff options
Diffstat (limited to 'intl/icu/source/i18n/tznames.cpp')
| -rw-r--r-- | intl/icu/source/i18n/tznames.cpp | 513 |
1 files changed, 513 insertions, 0 deletions
diff --git a/intl/icu/source/i18n/tznames.cpp b/intl/icu/source/i18n/tznames.cpp new file mode 100644 index 000000000..6aefd13b5 --- /dev/null +++ b/intl/icu/source/i18n/tznames.cpp @@ -0,0 +1,513 @@ +// Copyright (C) 2016 and later: Unicode, Inc. and others. +// License & terms of use: http://www.unicode.org/copyright.html +/* +******************************************************************************* +* Copyright (C) 2011-2015, International Business Machines Corporation and * +* others. All Rights Reserved. * +******************************************************************************* +*/ + +#include "unicode/utypes.h" + +#if !UCONFIG_NO_FORMATTING + +#include "unicode/locid.h" +#include "unicode/tznames.h" +#include "unicode/uenum.h" +#include "cmemory.h" +#include "cstring.h" +#include "mutex.h" +#include "putilimp.h" +#include "tznames_impl.h" +#include "uassert.h" +#include "ucln_in.h" +#include "uhash.h" +#include "umutex.h" +#include "uvector.h" + + +U_NAMESPACE_BEGIN + +// TimeZoneNames object cache handling +static UMutex gTimeZoneNamesLock = U_MUTEX_INITIALIZER; +static UHashtable *gTimeZoneNamesCache = NULL; +static UBool gTimeZoneNamesCacheInitialized = FALSE; + +// Access count - incremented every time up to SWEEP_INTERVAL, +// then reset to 0 +static int32_t gAccessCount = 0; + +// Interval for calling the cache sweep function - every 100 times +#define SWEEP_INTERVAL 100 + +// Cache expiration in millisecond. When a cached entry is no +// longer referenced and exceeding this threshold since last +// access time, then the cache entry will be deleted by the sweep +// function. For now, 3 minutes. +#define CACHE_EXPIRATION 180000.0 + +typedef struct TimeZoneNamesCacheEntry { + TimeZoneNames* names; + int32_t refCount; + double lastAccess; +} TimeZoneNamesCacheEntry; + +U_CDECL_BEGIN +/** + * Cleanup callback func + */ +static UBool U_CALLCONV timeZoneNames_cleanup(void) +{ + if (gTimeZoneNamesCache != NULL) { + uhash_close(gTimeZoneNamesCache); + gTimeZoneNamesCache = NULL; + } + gTimeZoneNamesCacheInitialized = FALSE; + return TRUE; +} + +/** + * Deleter for TimeZoneNamesCacheEntry + */ +static void U_CALLCONV +deleteTimeZoneNamesCacheEntry(void *obj) { + icu::TimeZoneNamesCacheEntry *entry = (icu::TimeZoneNamesCacheEntry*)obj; + delete (icu::TimeZoneNamesImpl*) entry->names; + uprv_free(entry); +} +U_CDECL_END + +/** + * Function used for removing unreferrenced cache entries exceeding + * the expiration time. This function must be called with in the mutex + * block. + */ +static void sweepCache() { + int32_t pos = UHASH_FIRST; + const UHashElement* elem; + double now = (double)uprv_getUTCtime(); + + while ((elem = uhash_nextElement(gTimeZoneNamesCache, &pos))) { + TimeZoneNamesCacheEntry *entry = (TimeZoneNamesCacheEntry *)elem->value.pointer; + if (entry->refCount <= 0 && (now - entry->lastAccess) > CACHE_EXPIRATION) { + // delete this entry + uhash_removeElement(gTimeZoneNamesCache, elem); + } + } +} + +// --------------------------------------------------- +// TimeZoneNamesDelegate +// --------------------------------------------------- +class TimeZoneNamesDelegate : public TimeZoneNames { +public: + TimeZoneNamesDelegate(const Locale& locale, UErrorCode& status); + virtual ~TimeZoneNamesDelegate(); + + virtual UBool operator==(const TimeZoneNames& other) const; + virtual UBool operator!=(const TimeZoneNames& other) const {return !operator==(other);}; + virtual TimeZoneNames* clone() const; + + StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const; + StringEnumeration* getAvailableMetaZoneIDs(const UnicodeString& tzID, UErrorCode& status) const; + UnicodeString& getMetaZoneID(const UnicodeString& tzID, UDate date, UnicodeString& mzID) const; + UnicodeString& getReferenceZoneID(const UnicodeString& mzID, const char* region, UnicodeString& tzID) const; + + UnicodeString& getMetaZoneDisplayName(const UnicodeString& mzID, UTimeZoneNameType type, UnicodeString& name) const; + UnicodeString& getTimeZoneDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UnicodeString& name) const; + + UnicodeString& getExemplarLocationName(const UnicodeString& tzID, UnicodeString& name) const; + + void loadAllDisplayNames(UErrorCode& status); + void getDisplayNames(const UnicodeString& tzID, const UTimeZoneNameType types[], int32_t numTypes, UDate date, UnicodeString dest[], UErrorCode& status) const; + + MatchInfoCollection* find(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const; +private: + TimeZoneNamesDelegate(); + TimeZoneNamesCacheEntry* fTZnamesCacheEntry; +}; + +TimeZoneNamesDelegate::TimeZoneNamesDelegate() +: fTZnamesCacheEntry(0) { +} + +TimeZoneNamesDelegate::TimeZoneNamesDelegate(const Locale& locale, UErrorCode& status) { + Mutex lock(&gTimeZoneNamesLock); + if (!gTimeZoneNamesCacheInitialized) { + // Create empty hashtable if it is not already initialized. + gTimeZoneNamesCache = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status); + if (U_SUCCESS(status)) { + uhash_setKeyDeleter(gTimeZoneNamesCache, uprv_free); + uhash_setValueDeleter(gTimeZoneNamesCache, deleteTimeZoneNamesCacheEntry); + gTimeZoneNamesCacheInitialized = TRUE; + ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONENAMES, timeZoneNames_cleanup); + } + } + + if (U_FAILURE(status)) { + return; + } + + // Check the cache, if not available, create new one and cache + TimeZoneNamesCacheEntry *cacheEntry = NULL; + + const char *key = locale.getName(); + cacheEntry = (TimeZoneNamesCacheEntry *)uhash_get(gTimeZoneNamesCache, key); + if (cacheEntry == NULL) { + TimeZoneNames *tznames = NULL; + char *newKey = NULL; + + tznames = new TimeZoneNamesImpl(locale, status); + if (tznames == NULL) { + status = U_MEMORY_ALLOCATION_ERROR; + } + if (U_SUCCESS(status)) { + newKey = (char *)uprv_malloc(uprv_strlen(key) + 1); + if (newKey == NULL) { + status = U_MEMORY_ALLOCATION_ERROR; + } else { + uprv_strcpy(newKey, key); + } + } + if (U_SUCCESS(status)) { + cacheEntry = (TimeZoneNamesCacheEntry *)uprv_malloc(sizeof(TimeZoneNamesCacheEntry)); + if (cacheEntry == NULL) { + status = U_MEMORY_ALLOCATION_ERROR; + } else { + cacheEntry->names = tznames; + cacheEntry->refCount = 1; + cacheEntry->lastAccess = (double)uprv_getUTCtime(); + + uhash_put(gTimeZoneNamesCache, newKey, cacheEntry, &status); + } + } + if (U_FAILURE(status)) { + if (tznames != NULL) { + delete tznames; + } + if (newKey != NULL) { + uprv_free(newKey); + } + if (cacheEntry != NULL) { + uprv_free(cacheEntry); + } + cacheEntry = NULL; + } + } else { + // Update the reference count + cacheEntry->refCount++; + cacheEntry->lastAccess = (double)uprv_getUTCtime(); + } + gAccessCount++; + if (gAccessCount >= SWEEP_INTERVAL) { + // sweep + sweepCache(); + gAccessCount = 0; + } + fTZnamesCacheEntry = cacheEntry; +} + +TimeZoneNamesDelegate::~TimeZoneNamesDelegate() { + umtx_lock(&gTimeZoneNamesLock); + { + if (fTZnamesCacheEntry) { + U_ASSERT(fTZnamesCacheEntry->refCount > 0); + // Just decrement the reference count + fTZnamesCacheEntry->refCount--; + } + } + umtx_unlock(&gTimeZoneNamesLock); +} + +UBool +TimeZoneNamesDelegate::operator==(const TimeZoneNames& other) const { + if (this == &other) { + return TRUE; + } + // Just compare if the other object also use the same + // cache entry + const TimeZoneNamesDelegate* rhs = dynamic_cast<const TimeZoneNamesDelegate*>(&other); + if (rhs) { + return fTZnamesCacheEntry == rhs->fTZnamesCacheEntry; + } + return FALSE; +} + +TimeZoneNames* +TimeZoneNamesDelegate::clone() const { + TimeZoneNamesDelegate* other = new TimeZoneNamesDelegate(); + if (other != NULL) { + umtx_lock(&gTimeZoneNamesLock); + { + // Just increment the reference count + fTZnamesCacheEntry->refCount++; + other->fTZnamesCacheEntry = fTZnamesCacheEntry; + } + umtx_unlock(&gTimeZoneNamesLock); + } + return other; +} + +StringEnumeration* +TimeZoneNamesDelegate::getAvailableMetaZoneIDs(UErrorCode& status) const { + return fTZnamesCacheEntry->names->getAvailableMetaZoneIDs(status); +} + +StringEnumeration* +TimeZoneNamesDelegate::getAvailableMetaZoneIDs(const UnicodeString& tzID, UErrorCode& status) const { + return fTZnamesCacheEntry->names->getAvailableMetaZoneIDs(tzID, status); +} + +UnicodeString& +TimeZoneNamesDelegate::getMetaZoneID(const UnicodeString& tzID, UDate date, UnicodeString& mzID) const { + return fTZnamesCacheEntry->names->getMetaZoneID(tzID, date, mzID); +} + +UnicodeString& +TimeZoneNamesDelegate::getReferenceZoneID(const UnicodeString& mzID, const char* region, UnicodeString& tzID) const { + return fTZnamesCacheEntry->names->getReferenceZoneID(mzID, region, tzID); +} + +UnicodeString& +TimeZoneNamesDelegate::getMetaZoneDisplayName(const UnicodeString& mzID, UTimeZoneNameType type, UnicodeString& name) const { + return fTZnamesCacheEntry->names->getMetaZoneDisplayName(mzID, type, name); +} + +UnicodeString& +TimeZoneNamesDelegate::getTimeZoneDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UnicodeString& name) const { + return fTZnamesCacheEntry->names->getTimeZoneDisplayName(tzID, type, name); +} + +UnicodeString& +TimeZoneNamesDelegate::getExemplarLocationName(const UnicodeString& tzID, UnicodeString& name) const { + return fTZnamesCacheEntry->names->getExemplarLocationName(tzID, name); +} + +void +TimeZoneNamesDelegate::loadAllDisplayNames(UErrorCode& status) { + fTZnamesCacheEntry->names->loadAllDisplayNames(status); +} + +void +TimeZoneNamesDelegate::getDisplayNames(const UnicodeString& tzID, const UTimeZoneNameType types[], int32_t numTypes, UDate date, UnicodeString dest[], UErrorCode& status) const { + fTZnamesCacheEntry->names->getDisplayNames(tzID, types, numTypes, date, dest, status); +} + +TimeZoneNames::MatchInfoCollection* +TimeZoneNamesDelegate::find(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const { + return fTZnamesCacheEntry->names->find(text, start, types, status); +} + +// --------------------------------------------------- +// TimeZoneNames base class +// --------------------------------------------------- +TimeZoneNames::~TimeZoneNames() { +} + +TimeZoneNames* +TimeZoneNames::createInstance(const Locale& locale, UErrorCode& status) { + TimeZoneNames *instance = NULL; + if (U_SUCCESS(status)) { + instance = new TimeZoneNamesDelegate(locale, status); + if (instance == NULL && U_SUCCESS(status)) { + status = U_MEMORY_ALLOCATION_ERROR; + } + } + return instance; +} + +TimeZoneNames* +TimeZoneNames::createTZDBInstance(const Locale& locale, UErrorCode& status) { + TimeZoneNames *instance = NULL; + if (U_SUCCESS(status)) { + instance = new TZDBTimeZoneNames(locale); + if (instance == NULL && U_SUCCESS(status)) { + status = U_MEMORY_ALLOCATION_ERROR; + } + } + return instance; +} + +UnicodeString& +TimeZoneNames::getExemplarLocationName(const UnicodeString& tzID, UnicodeString& name) const { + return TimeZoneNamesImpl::getDefaultExemplarLocationName(tzID, name); +} + +UnicodeString& +TimeZoneNames::getDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UDate date, UnicodeString& name) const { + getTimeZoneDisplayName(tzID, type, name); + if (name.isEmpty()) { + UChar mzIDBuf[32]; + UnicodeString mzID(mzIDBuf, 0, UPRV_LENGTHOF(mzIDBuf)); + getMetaZoneID(tzID, date, mzID); + getMetaZoneDisplayName(mzID, type, name); + } + return name; +} + +// Empty default implementation, to be overriden in tznames_impl.cpp. +void +TimeZoneNames::loadAllDisplayNames(UErrorCode& /*status*/) { +} + +// A default, lightweight implementation of getDisplayNames. +// Overridden in tznames_impl.cpp. +void +TimeZoneNames::getDisplayNames(const UnicodeString& tzID, const UTimeZoneNameType types[], int32_t numTypes, UDate date, UnicodeString dest[], UErrorCode& status) const { + if (U_FAILURE(status)) { return; } + if (tzID.isEmpty()) { return; } + UnicodeString mzID; + for (int i = 0; i < numTypes; i++) { + getTimeZoneDisplayName(tzID, types[i], dest[i]); + if (dest[i].isEmpty()) { + if (mzID.isEmpty()) { + getMetaZoneID(tzID, date, mzID); + } + getMetaZoneDisplayName(mzID, types[i], dest[i]); + } + } +} + + +struct MatchInfo : UMemory { + UTimeZoneNameType nameType; + UnicodeString id; + int32_t matchLength; + UBool isTZID; + + MatchInfo(UTimeZoneNameType nameType, int32_t matchLength, const UnicodeString* tzID, const UnicodeString* mzID) { + this->nameType = nameType; + this->matchLength = matchLength; + if (tzID != NULL) { + this->id.setTo(*tzID); + this->isTZID = TRUE; + } else { + this->id.setTo(*mzID); + this->isTZID = FALSE; + } + } +}; + +U_CDECL_BEGIN +static void U_CALLCONV +deleteMatchInfo(void *obj) { + delete static_cast<MatchInfo *>(obj); +} +U_CDECL_END + +// --------------------------------------------------- +// MatchInfoCollection class +// --------------------------------------------------- +TimeZoneNames::MatchInfoCollection::MatchInfoCollection() +: fMatches(NULL) { +} + +TimeZoneNames::MatchInfoCollection::~MatchInfoCollection() { + if (fMatches != NULL) { + delete fMatches; + } +} + +void +TimeZoneNames::MatchInfoCollection::addZone(UTimeZoneNameType nameType, int32_t matchLength, + const UnicodeString& tzID, UErrorCode& status) { + if (U_FAILURE(status)) { + return; + } + MatchInfo* matchInfo = new MatchInfo(nameType, matchLength, &tzID, NULL); + if (matchInfo == NULL) { + status = U_MEMORY_ALLOCATION_ERROR; + return; + } + matches(status)->addElement(matchInfo, status); + if (U_FAILURE(status)) { + delete matchInfo; + } +} + +void +TimeZoneNames::MatchInfoCollection::addMetaZone(UTimeZoneNameType nameType, int32_t matchLength, + const UnicodeString& mzID, UErrorCode& status) { + if (U_FAILURE(status)) { + return; + } + MatchInfo* matchInfo = new MatchInfo(nameType, matchLength, NULL, &mzID); + if (matchInfo == NULL) { + status = U_MEMORY_ALLOCATION_ERROR; + return; + } + matches(status)->addElement(matchInfo, status); + if (U_FAILURE(status)) { + delete matchInfo; + } +} + +int32_t +TimeZoneNames::MatchInfoCollection::size() const { + if (fMatches == NULL) { + return 0; + } + return fMatches->size(); +} + +UTimeZoneNameType +TimeZoneNames::MatchInfoCollection::getNameTypeAt(int32_t idx) const { + const MatchInfo* match = (const MatchInfo*)fMatches->elementAt(idx); + if (match) { + return match->nameType; + } + return UTZNM_UNKNOWN; +} + +int32_t +TimeZoneNames::MatchInfoCollection::getMatchLengthAt(int32_t idx) const { + const MatchInfo* match = (const MatchInfo*)fMatches->elementAt(idx); + if (match) { + return match->matchLength; + } + return 0; +} + +UBool +TimeZoneNames::MatchInfoCollection::getTimeZoneIDAt(int32_t idx, UnicodeString& tzID) const { + tzID.remove(); + const MatchInfo* match = (const MatchInfo*)fMatches->elementAt(idx); + if (match && match->isTZID) { + tzID.setTo(match->id); + return TRUE; + } + return FALSE; +} + +UBool +TimeZoneNames::MatchInfoCollection::getMetaZoneIDAt(int32_t idx, UnicodeString& mzID) const { + mzID.remove(); + const MatchInfo* match = (const MatchInfo*)fMatches->elementAt(idx); + if (match && !match->isTZID) { + mzID.setTo(match->id); + return TRUE; + } + return FALSE; +} + +UVector* +TimeZoneNames::MatchInfoCollection::matches(UErrorCode& status) { + if (U_FAILURE(status)) { + return NULL; + } + if (fMatches != NULL) { + return fMatches; + } + fMatches = new UVector(deleteMatchInfo, NULL, status); + if (fMatches == NULL) { + status = U_MEMORY_ALLOCATION_ERROR; + } else if (U_FAILURE(status)) { + delete fMatches; + fMatches = NULL; + } + return fMatches; +} + + +U_NAMESPACE_END +#endif |