| /* | |
| ******************************************************************************* | |
| * Copyright (C) 2011-2015, International Business Machines Corporation and | |
| * others. All Rights Reserved. | |
| ******************************************************************************* | |
| */ | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_FORMATTING | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #include "tzgnames.h" | |
| #include "unicode/basictz.h" | |
| #include "unicode/locdspnm.h" | |
| #include "unicode/msgfmt.h" | |
| #include "unicode/rbtz.h" | |
| #include "unicode/simpletz.h" | |
| #include "unicode/vtzone.h" | |
| #include "cmemory.h" | |
| #include "cstring.h" | |
| #include "mutex.h" | |
| #include "uhash.h" | |
| #include "uassert.h" | |
| #include "umutex.h" | |
| #include "uresimp.h" | |
| #include "ureslocs.h" | |
| #include "zonemeta.h" | |
| #include "tznames_impl.h" | |
| #include "olsontz.h" | |
| #include "ucln_in.h" | |
| U_NAMESPACE_BEGIN | |
| #define ZID_KEY_MAX 128 | |
| static const char gZoneStrings[] = "zoneStrings"; | |
| static const char gRegionFormatTag[] = "regionFormat"; | |
| static const char gFallbackFormatTag[] = "fallbackFormat"; | |
| static const UChar gEmpty[] = {0x00}; | |
| static const UChar gDefRegionPattern[] = {0x7B, 0x30, 0x7D, 0x00}; // "{0}" | |
| static const UChar gDefFallbackPattern[] = {0x7B, 0x31, 0x7D, 0x20, 0x28, 0x7B, 0x30, 0x7D, 0x29, 0x00}; // "{1} ({0})" | |
| static const double kDstCheckRange = (double)184*U_MILLIS_PER_DAY; | |
| U_CDECL_BEGIN | |
| typedef struct PartialLocationKey { | |
| const UChar* tzID; | |
| const UChar* mzID; | |
| UBool isLong; | |
| } PartialLocationKey; | |
| /** | |
| * Hash function for partial location name hash key | |
| */ | |
| static int32_t U_CALLCONV | |
| hashPartialLocationKey(const UHashTok key) { | |
| // <tzID>&<mzID>#[L|S] | |
| PartialLocationKey *p = (PartialLocationKey *)key.pointer; | |
| UnicodeString str(p->tzID); | |
| str.append((UChar)0x26) | |
| .append(p->mzID, -1) | |
| .append((UChar)0x23) | |
| .append((UChar)(p->isLong ? 0x4C : 0x53)); | |
| return str.hashCode(); | |
| } | |
| /** | |
| * Comparer for partial location name hash key | |
| */ | |
| static UBool U_CALLCONV | |
| comparePartialLocationKey(const UHashTok key1, const UHashTok key2) { | |
| PartialLocationKey *p1 = (PartialLocationKey *)key1.pointer; | |
| PartialLocationKey *p2 = (PartialLocationKey *)key2.pointer; | |
| if (p1 == p2) { | |
| return TRUE; | |
| } | |
| if (p1 == NULL || p2 == NULL) { | |
| return FALSE; | |
| } | |
| // We just check identity of tzID/mzID | |
| return (p1->tzID == p2->tzID && p1->mzID == p2->mzID && p1->isLong == p2->isLong); | |
| } | |
| /** | |
| * Deleter for GNameInfo | |
| */ | |
| static void U_CALLCONV | |
| deleteGNameInfo(void *obj) { | |
| uprv_free(obj); | |
| } | |
| /** | |
| * GNameInfo stores zone name information in the local trie | |
| */ | |
| typedef struct GNameInfo { | |
| UTimeZoneGenericNameType type; | |
| const UChar* tzID; | |
| } ZNameInfo; | |
| /** | |
| * GMatchInfo stores zone name match information used by find method | |
| */ | |
| typedef struct GMatchInfo { | |
| const GNameInfo* gnameInfo; | |
| int32_t matchLength; | |
| UTimeZoneFormatTimeType timeType; | |
| } ZMatchInfo; | |
| U_CDECL_END | |
| // --------------------------------------------------- | |
| // The class stores time zone generic name match information | |
| // --------------------------------------------------- | |
| class TimeZoneGenericNameMatchInfo : public UMemory { | |
| public: | |
| TimeZoneGenericNameMatchInfo(UVector* matches); | |
| ~TimeZoneGenericNameMatchInfo(); | |
| int32_t size() const; | |
| UTimeZoneGenericNameType getGenericNameType(int32_t index) const; | |
| int32_t getMatchLength(int32_t index) const; | |
| UnicodeString& getTimeZoneID(int32_t index, UnicodeString& tzID) const; | |
| private: | |
| UVector* fMatches; // vector of MatchEntry | |
| }; | |
| TimeZoneGenericNameMatchInfo::TimeZoneGenericNameMatchInfo(UVector* matches) | |
| : fMatches(matches) { | |
| } | |
| TimeZoneGenericNameMatchInfo::~TimeZoneGenericNameMatchInfo() { | |
| if (fMatches != NULL) { | |
| delete fMatches; | |
| } | |
| } | |
| int32_t | |
| TimeZoneGenericNameMatchInfo::size() const { | |
| if (fMatches == NULL) { | |
| return 0; | |
| } | |
| return fMatches->size(); | |
| } | |
| UTimeZoneGenericNameType | |
| TimeZoneGenericNameMatchInfo::getGenericNameType(int32_t index) const { | |
| GMatchInfo *minfo = (GMatchInfo *)fMatches->elementAt(index); | |
| if (minfo != NULL) { | |
| return static_cast<UTimeZoneGenericNameType>(minfo->gnameInfo->type); | |
| } | |
| return UTZGNM_UNKNOWN; | |
| } | |
| int32_t | |
| TimeZoneGenericNameMatchInfo::getMatchLength(int32_t index) const { | |
| ZMatchInfo *minfo = (ZMatchInfo *)fMatches->elementAt(index); | |
| if (minfo != NULL) { | |
| return minfo->matchLength; | |
| } | |
| return -1; | |
| } | |
| UnicodeString& | |
| TimeZoneGenericNameMatchInfo::getTimeZoneID(int32_t index, UnicodeString& tzID) const { | |
| GMatchInfo *minfo = (GMatchInfo *)fMatches->elementAt(index); | |
| if (minfo != NULL && minfo->gnameInfo->tzID != NULL) { | |
| tzID.setTo(TRUE, minfo->gnameInfo->tzID, -1); | |
| } else { | |
| tzID.setToBogus(); | |
| } | |
| return tzID; | |
| } | |
| // --------------------------------------------------- | |
| // GNameSearchHandler | |
| // --------------------------------------------------- | |
| class GNameSearchHandler : public TextTrieMapSearchResultHandler { | |
| public: | |
| GNameSearchHandler(uint32_t types); | |
| virtual ~GNameSearchHandler(); | |
| UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status); | |
| UVector* getMatches(int32_t& maxMatchLen); | |
| private: | |
| uint32_t fTypes; | |
| UVector* fResults; | |
| int32_t fMaxMatchLen; | |
| }; | |
| GNameSearchHandler::GNameSearchHandler(uint32_t types) | |
| : fTypes(types), fResults(NULL), fMaxMatchLen(0) { | |
| } | |
| GNameSearchHandler::~GNameSearchHandler() { | |
| if (fResults != NULL) { | |
| delete fResults; | |
| } | |
| } | |
| UBool | |
| GNameSearchHandler::handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return FALSE; | |
| } | |
| if (node->hasValues()) { | |
| int32_t valuesCount = node->countValues(); | |
| for (int32_t i = 0; i < valuesCount; i++) { | |
| GNameInfo *nameinfo = (ZNameInfo *)node->getValue(i); | |
| if (nameinfo == NULL) { | |
| break; | |
| } | |
| if ((nameinfo->type & fTypes) != 0) { | |
| // matches a requested type | |
| if (fResults == NULL) { | |
| fResults = new UVector(uprv_free, NULL, status); | |
| if (fResults == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| } | |
| if (U_SUCCESS(status)) { | |
| U_ASSERT(fResults != NULL); | |
| GMatchInfo *gmatch = (GMatchInfo *)uprv_malloc(sizeof(GMatchInfo)); | |
| if (gmatch == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| } else { | |
| // add the match to the vector | |
| gmatch->gnameInfo = nameinfo; | |
| gmatch->matchLength = matchLength; | |
| gmatch->timeType = UTZFMT_TIME_TYPE_UNKNOWN; | |
| fResults->addElement(gmatch, status); | |
| if (U_FAILURE(status)) { | |
| uprv_free(gmatch); | |
| } else { | |
| if (matchLength > fMaxMatchLen) { | |
| fMaxMatchLen = matchLength; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return TRUE; | |
| } | |
| UVector* | |
| GNameSearchHandler::getMatches(int32_t& maxMatchLen) { | |
| // give the ownership to the caller | |
| UVector *results = fResults; | |
| maxMatchLen = fMaxMatchLen; | |
| // reset | |
| fResults = NULL; | |
| fMaxMatchLen = 0; | |
| return results; | |
| } | |
| static UMutex gLock = U_MUTEX_INITIALIZER; | |
| class TZGNCore : public UMemory { | |
| public: | |
| TZGNCore(const Locale& locale, UErrorCode& status); | |
| virtual ~TZGNCore(); | |
| UnicodeString& getDisplayName(const TimeZone& tz, UTimeZoneGenericNameType type, | |
| UDate date, UnicodeString& name) const; | |
| UnicodeString& getGenericLocationName(const UnicodeString& tzCanonicalID, UnicodeString& name) const; | |
| int32_t findBestMatch(const UnicodeString& text, int32_t start, uint32_t types, | |
| UnicodeString& tzID, UTimeZoneFormatTimeType& timeType, UErrorCode& status) const; | |
| private: | |
| Locale fLocale; | |
| const TimeZoneNames* fTimeZoneNames; | |
| UHashtable* fLocationNamesMap; | |
| UHashtable* fPartialLocationNamesMap; | |
| MessageFormat* fRegionFormat; | |
| MessageFormat* fFallbackFormat; | |
| LocaleDisplayNames* fLocaleDisplayNames; | |
| ZNStringPool fStringPool; | |
| TextTrieMap fGNamesTrie; | |
| UBool fGNamesTrieFullyLoaded; | |
| char fTargetRegion[ULOC_COUNTRY_CAPACITY]; | |
| void initialize(const Locale& locale, UErrorCode& status); | |
| void cleanup(); | |
| void loadStrings(const UnicodeString& tzCanonicalID); | |
| const UChar* getGenericLocationName(const UnicodeString& tzCanonicalID); | |
| UnicodeString& formatGenericNonLocationName(const TimeZone& tz, UTimeZoneGenericNameType type, | |
| UDate date, UnicodeString& name) const; | |
| UnicodeString& getPartialLocationName(const UnicodeString& tzCanonicalID, | |
| const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName, | |
| UnicodeString& name) const; | |
| const UChar* getPartialLocationName(const UnicodeString& tzCanonicalID, | |
| const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName); | |
| TimeZoneGenericNameMatchInfo* findLocal(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const; | |
| TimeZoneNames::MatchInfoCollection* findTimeZoneNames(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const; | |
| }; | |
| // --------------------------------------------------- | |
| // TZGNCore - core implmentation of TimeZoneGenericNames | |
| // | |
| // TimeZoneGenericNames is parallel to TimeZoneNames, | |
| // but handles run-time generated time zone names. | |
| // This is the main part of this module. | |
| // --------------------------------------------------- | |
| TZGNCore::TZGNCore(const Locale& locale, UErrorCode& status) | |
| : fLocale(locale), | |
| fTimeZoneNames(NULL), | |
| fLocationNamesMap(NULL), | |
| fPartialLocationNamesMap(NULL), | |
| fRegionFormat(NULL), | |
| fFallbackFormat(NULL), | |
| fLocaleDisplayNames(NULL), | |
| fStringPool(status), | |
| fGNamesTrie(TRUE, deleteGNameInfo), | |
| fGNamesTrieFullyLoaded(FALSE) { | |
| initialize(locale, status); | |
| } | |
| TZGNCore::~TZGNCore() { | |
| cleanup(); | |
| } | |
| void | |
| TZGNCore::initialize(const Locale& locale, UErrorCode& status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| // TimeZoneNames | |
| fTimeZoneNames = TimeZoneNames::createInstance(locale, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| // Initialize format patterns | |
| UnicodeString rpat(TRUE, gDefRegionPattern, -1); | |
| UnicodeString fpat(TRUE, gDefFallbackPattern, -1); | |
| UErrorCode tmpsts = U_ZERO_ERROR; // OK with fallback warning.. | |
| UResourceBundle *zoneStrings = ures_open(U_ICUDATA_ZONE, locale.getName(), &tmpsts); | |
| zoneStrings = ures_getByKeyWithFallback(zoneStrings, gZoneStrings, zoneStrings, &tmpsts); | |
| if (U_SUCCESS(tmpsts)) { | |
| const UChar *regionPattern = ures_getStringByKeyWithFallback(zoneStrings, gRegionFormatTag, NULL, &tmpsts); | |
| if (U_SUCCESS(tmpsts) && u_strlen(regionPattern) > 0) { | |
| rpat.setTo(regionPattern, -1); | |
| } | |
| tmpsts = U_ZERO_ERROR; | |
| const UChar *fallbackPattern = ures_getStringByKeyWithFallback(zoneStrings, gFallbackFormatTag, NULL, &tmpsts); | |
| if (U_SUCCESS(tmpsts) && u_strlen(fallbackPattern) > 0) { | |
| fpat.setTo(fallbackPattern, -1); | |
| } | |
| } | |
| ures_close(zoneStrings); | |
| fRegionFormat = new MessageFormat(rpat, status); | |
| if (fRegionFormat == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| fFallbackFormat = new MessageFormat(fpat, status); | |
| if (fFallbackFormat == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| if (U_FAILURE(status)) { | |
| cleanup(); | |
| return; | |
| } | |
| // locale display names | |
| fLocaleDisplayNames = LocaleDisplayNames::createInstance(locale); | |
| // hash table for names - no key/value deleters | |
| fLocationNamesMap = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status); | |
| if (U_FAILURE(status)) { | |
| cleanup(); | |
| return; | |
| } | |
| fPartialLocationNamesMap = uhash_open(hashPartialLocationKey, comparePartialLocationKey, NULL, &status); | |
| if (U_FAILURE(status)) { | |
| cleanup(); | |
| return; | |
| } | |
| uhash_setKeyDeleter(fPartialLocationNamesMap, uprv_free); | |
| // no value deleter | |
| // target region | |
| const char* region = fLocale.getCountry(); | |
| int32_t regionLen = uprv_strlen(region); | |
| if (regionLen == 0) { | |
| char loc[ULOC_FULLNAME_CAPACITY]; | |
| uloc_addLikelySubtags(fLocale.getName(), loc, sizeof(loc), &status); | |
| regionLen = uloc_getCountry(loc, fTargetRegion, sizeof(fTargetRegion), &status); | |
| if (U_SUCCESS(status)) { | |
| fTargetRegion[regionLen] = 0; | |
| } else { | |
| cleanup(); | |
| return; | |
| } | |
| } else if (regionLen < (int32_t)sizeof(fTargetRegion)) { | |
| uprv_strcpy(fTargetRegion, region); | |
| } else { | |
| fTargetRegion[0] = 0; | |
| } | |
| // preload generic names for the default zone | |
| TimeZone *tz = TimeZone::createDefault(); | |
| const UChar *tzID = ZoneMeta::getCanonicalCLDRID(*tz); | |
| if (tzID != NULL) { | |
| loadStrings(UnicodeString(TRUE, tzID, -1)); | |
| } | |
| delete tz; | |
| } | |
| void | |
| TZGNCore::cleanup() { | |
| if (fRegionFormat != NULL) { | |
| delete fRegionFormat; | |
| } | |
| if (fFallbackFormat != NULL) { | |
| delete fFallbackFormat; | |
| } | |
| if (fLocaleDisplayNames != NULL) { | |
| delete fLocaleDisplayNames; | |
| } | |
| if (fTimeZoneNames != NULL) { | |
| delete fTimeZoneNames; | |
| } | |
| uhash_close(fLocationNamesMap); | |
| uhash_close(fPartialLocationNamesMap); | |
| } | |
| UnicodeString& | |
| TZGNCore::getDisplayName(const TimeZone& tz, UTimeZoneGenericNameType type, UDate date, UnicodeString& name) const { | |
| name.setToBogus(); | |
| switch (type) { | |
| case UTZGNM_LOCATION: | |
| { | |
| const UChar* tzCanonicalID = ZoneMeta::getCanonicalCLDRID(tz); | |
| if (tzCanonicalID != NULL) { | |
| getGenericLocationName(UnicodeString(TRUE, tzCanonicalID, -1), name); | |
| } | |
| } | |
| break; | |
| case UTZGNM_LONG: | |
| case UTZGNM_SHORT: | |
| formatGenericNonLocationName(tz, type, date, name); | |
| if (name.isEmpty()) { | |
| const UChar* tzCanonicalID = ZoneMeta::getCanonicalCLDRID(tz); | |
| if (tzCanonicalID != NULL) { | |
| getGenericLocationName(UnicodeString(TRUE, tzCanonicalID, -1), name); | |
| } | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| return name; | |
| } | |
| UnicodeString& | |
| TZGNCore::getGenericLocationName(const UnicodeString& tzCanonicalID, UnicodeString& name) const { | |
| if (tzCanonicalID.isEmpty()) { | |
| name.setToBogus(); | |
| return name; | |
| } | |
| const UChar *locname = NULL; | |
| TZGNCore *nonConstThis = const_cast<TZGNCore *>(this); | |
| umtx_lock(&gLock); | |
| { | |
| locname = nonConstThis->getGenericLocationName(tzCanonicalID); | |
| } | |
| umtx_unlock(&gLock); | |
| if (locname == NULL) { | |
| name.setToBogus(); | |
| } else { | |
| name.setTo(locname, u_strlen(locname)); | |
| } | |
| return name; | |
| } | |
| /* | |
| * This method updates the cache and must be called with a lock | |
| */ | |
| const UChar* | |
| TZGNCore::getGenericLocationName(const UnicodeString& tzCanonicalID) { | |
| U_ASSERT(!tzCanonicalID.isEmpty()); | |
| if (tzCanonicalID.length() > ZID_KEY_MAX) { | |
| return NULL; | |
| } | |
| UErrorCode status = U_ZERO_ERROR; | |
| UChar tzIDKey[ZID_KEY_MAX + 1]; | |
| int32_t tzIDKeyLen = tzCanonicalID.extract(tzIDKey, ZID_KEY_MAX + 1, status); | |
| U_ASSERT(status == U_ZERO_ERROR); // already checked length above | |
| tzIDKey[tzIDKeyLen] = 0; | |
| const UChar *locname = (const UChar *)uhash_get(fLocationNamesMap, tzIDKey); | |
| if (locname != NULL) { | |
| // gEmpty indicate the name is not available | |
| if (locname == gEmpty) { | |
| return NULL; | |
| } | |
| return locname; | |
| } | |
| // Construct location name | |
| UnicodeString name; | |
| UnicodeString usCountryCode; | |
| UBool isPrimary = FALSE; | |
| ZoneMeta::getCanonicalCountry(tzCanonicalID, usCountryCode, &isPrimary); | |
| if (!usCountryCode.isEmpty()) { | |
| FieldPosition fpos; | |
| if (isPrimary) { | |
| // If this is the primary zone in the country, use the country name. | |
| char countryCode[ULOC_COUNTRY_CAPACITY]; | |
| U_ASSERT(usCountryCode.length() < ULOC_COUNTRY_CAPACITY); | |
| int32_t ccLen = usCountryCode.extract(0, usCountryCode.length(), countryCode, sizeof(countryCode), US_INV); | |
| countryCode[ccLen] = 0; | |
| UnicodeString country; | |
| fLocaleDisplayNames->regionDisplayName(countryCode, country); | |
| Formattable param[] = { | |
| Formattable(country) | |
| }; | |
| fRegionFormat->format(param, 1, name, fpos, status); | |
| } else { | |
| // If this is not the primary zone in the country, | |
| // use the exemplar city name. | |
| // getExemplarLocationName should retur non-empty string | |
| // if the time zone is associated with a region | |
| UnicodeString city; | |
| fTimeZoneNames->getExemplarLocationName(tzCanonicalID, city); | |
| Formattable param[] = { | |
| Formattable(city), | |
| }; | |
| fRegionFormat->format(param, 1, name, fpos, status); | |
| } | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| } | |
| locname = name.isEmpty() ? NULL : fStringPool.get(name, status); | |
| if (U_SUCCESS(status)) { | |
| // Cache the result | |
| const UChar* cacheID = ZoneMeta::findTimeZoneID(tzCanonicalID); | |
| U_ASSERT(cacheID != NULL); | |
| if (locname == NULL) { | |
| // gEmpty to indicate - no location name available | |
| uhash_put(fLocationNamesMap, (void *)cacheID, (void *)gEmpty, &status); | |
| } else { | |
| uhash_put(fLocationNamesMap, (void *)cacheID, (void *)locname, &status); | |
| if (U_FAILURE(status)) { | |
| locname = NULL; | |
| } else { | |
| // put the name info into the trie | |
| GNameInfo *nameinfo = (ZNameInfo *)uprv_malloc(sizeof(GNameInfo)); | |
| if (nameinfo != NULL) { | |
| nameinfo->type = UTZGNM_LOCATION; | |
| nameinfo->tzID = cacheID; | |
| fGNamesTrie.put(locname, nameinfo, status); | |
| } | |
| } | |
| } | |
| } | |
| return locname; | |
| } | |
| UnicodeString& | |
| TZGNCore::formatGenericNonLocationName(const TimeZone& tz, UTimeZoneGenericNameType type, UDate date, UnicodeString& name) const { | |
| U_ASSERT(type == UTZGNM_LONG || type == UTZGNM_SHORT); | |
| name.setToBogus(); | |
| const UChar* uID = ZoneMeta::getCanonicalCLDRID(tz); | |
| if (uID == NULL) { | |
| return name; | |
| } | |
| UnicodeString tzID(TRUE, uID, -1); | |
| // Try to get a name from time zone first | |
| UTimeZoneNameType nameType = (type == UTZGNM_LONG) ? UTZNM_LONG_GENERIC : UTZNM_SHORT_GENERIC; | |
| fTimeZoneNames->getTimeZoneDisplayName(tzID, nameType, name); | |
| if (!name.isEmpty()) { | |
| return name; | |
| } | |
| // Try meta zone | |
| UChar mzIDBuf[32]; | |
| UnicodeString mzID(mzIDBuf, 0, UPRV_LENGTHOF(mzIDBuf)); | |
| fTimeZoneNames->getMetaZoneID(tzID, date, mzID); | |
| if (!mzID.isEmpty()) { | |
| UErrorCode status = U_ZERO_ERROR; | |
| UBool useStandard = FALSE; | |
| int32_t raw, sav; | |
| UChar tmpNameBuf[64]; | |
| tz.getOffset(date, FALSE, raw, sav, status); | |
| if (U_FAILURE(status)) { | |
| return name; | |
| } | |
| if (sav == 0) { | |
| useStandard = TRUE; | |
| TimeZone *tmptz = tz.clone(); | |
| // Check if the zone actually uses daylight saving time around the time | |
| BasicTimeZone *btz = NULL; | |
| if (dynamic_cast<OlsonTimeZone *>(tmptz) != NULL | |
| || dynamic_cast<SimpleTimeZone *>(tmptz) != NULL | |
| || dynamic_cast<RuleBasedTimeZone *>(tmptz) != NULL | |
| || dynamic_cast<VTimeZone *>(tmptz) != NULL) { | |
| btz = (BasicTimeZone*)tmptz; | |
| } | |
| if (btz != NULL) { | |
| TimeZoneTransition before; | |
| UBool beforTrs = btz->getPreviousTransition(date, TRUE, before); | |
| if (beforTrs | |
| && (date - before.getTime() < kDstCheckRange) | |
| && before.getFrom()->getDSTSavings() != 0) { | |
| useStandard = FALSE; | |
| } else { | |
| TimeZoneTransition after; | |
| UBool afterTrs = btz->getNextTransition(date, FALSE, after); | |
| if (afterTrs | |
| && (after.getTime() - date < kDstCheckRange) | |
| && after.getTo()->getDSTSavings() != 0) { | |
| useStandard = FALSE; | |
| } | |
| } | |
| } else { | |
| // If not BasicTimeZone... only if the instance is not an ICU's implementation. | |
| // We may get a wrong answer in edge case, but it should practically work OK. | |
| tmptz->getOffset(date - kDstCheckRange, FALSE, raw, sav, status); | |
| if (sav != 0) { | |
| useStandard = FALSE; | |
| } else { | |
| tmptz->getOffset(date + kDstCheckRange, FALSE, raw, sav, status); | |
| if (sav != 0){ | |
| useStandard = FALSE; | |
| } | |
| } | |
| if (U_FAILURE(status)) { | |
| delete tmptz; | |
| return name; | |
| } | |
| } | |
| delete tmptz; | |
| } | |
| if (useStandard) { | |
| UTimeZoneNameType stdNameType = (nameType == UTZNM_LONG_GENERIC) | |
| ? UTZNM_LONG_STANDARD : UTZNM_SHORT_STANDARD; | |
| UnicodeString stdName(tmpNameBuf, 0, UPRV_LENGTHOF(tmpNameBuf)); | |
| fTimeZoneNames->getDisplayName(tzID, stdNameType, date, stdName); | |
| if (!stdName.isEmpty()) { | |
| name.setTo(stdName); | |
| // TODO: revisit this issue later | |
| // In CLDR, a same display name is used for both generic and standard | |
| // for some meta zones in some locales. This looks like a data bugs. | |
| // For now, we check if the standard name is different from its generic | |
| // name below. | |
| UChar genNameBuf[64]; | |
| UnicodeString mzGenericName(genNameBuf, 0, UPRV_LENGTHOF(genNameBuf)); | |
| fTimeZoneNames->getMetaZoneDisplayName(mzID, nameType, mzGenericName); | |
| if (stdName.caseCompare(mzGenericName, 0) == 0) { | |
| name.setToBogus(); | |
| } | |
| } | |
| } | |
| if (name.isEmpty()) { | |
| // Get a name from meta zone | |
| UnicodeString mzName(tmpNameBuf, 0, UPRV_LENGTHOF(tmpNameBuf)); | |
| fTimeZoneNames->getMetaZoneDisplayName(mzID, nameType, mzName); | |
| if (!mzName.isEmpty()) { | |
| // Check if we need to use a partial location format. | |
| // This check is done by comparing offset with the meta zone's | |
| // golden zone at the given date. | |
| UChar idBuf[32]; | |
| UnicodeString goldenID(idBuf, 0, UPRV_LENGTHOF(idBuf)); | |
| fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, goldenID); | |
| if (!goldenID.isEmpty() && goldenID != tzID) { | |
| TimeZone *goldenZone = TimeZone::createTimeZone(goldenID); | |
| int32_t raw1, sav1; | |
| // Check offset in the golden zone with wall time. | |
| // With getOffset(date, false, offsets1), | |
| // you may get incorrect results because of time overlap at DST->STD | |
| // transition. | |
| goldenZone->getOffset(date + raw + sav, TRUE, raw1, sav1, status); | |
| delete goldenZone; | |
| if (U_SUCCESS(status)) { | |
| if (raw != raw1 || sav != sav1) { | |
| // Now we need to use a partial location format | |
| getPartialLocationName(tzID, mzID, (nameType == UTZNM_LONG_GENERIC), mzName, name); | |
| } else { | |
| name.setTo(mzName); | |
| } | |
| } | |
| } else { | |
| name.setTo(mzName); | |
| } | |
| } | |
| } | |
| } | |
| return name; | |
| } | |
| UnicodeString& | |
| TZGNCore::getPartialLocationName(const UnicodeString& tzCanonicalID, | |
| const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName, | |
| UnicodeString& name) const { | |
| name.setToBogus(); | |
| if (tzCanonicalID.isEmpty() || mzID.isEmpty() || mzDisplayName.isEmpty()) { | |
| return name; | |
| } | |
| const UChar *uplname = NULL; | |
| TZGNCore *nonConstThis = const_cast<TZGNCore *>(this); | |
| umtx_lock(&gLock); | |
| { | |
| uplname = nonConstThis->getPartialLocationName(tzCanonicalID, mzID, isLong, mzDisplayName); | |
| } | |
| umtx_unlock(&gLock); | |
| if (uplname == NULL) { | |
| name.setToBogus(); | |
| } else { | |
| name.setTo(TRUE, uplname, -1); | |
| } | |
| return name; | |
| } | |
| /* | |
| * This method updates the cache and must be called with a lock | |
| */ | |
| const UChar* | |
| TZGNCore::getPartialLocationName(const UnicodeString& tzCanonicalID, | |
| const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName) { | |
| U_ASSERT(!tzCanonicalID.isEmpty()); | |
| U_ASSERT(!mzID.isEmpty()); | |
| U_ASSERT(!mzDisplayName.isEmpty()); | |
| PartialLocationKey key; | |
| key.tzID = ZoneMeta::findTimeZoneID(tzCanonicalID); | |
| key.mzID = ZoneMeta::findMetaZoneID(mzID); | |
| key.isLong = isLong; | |
| U_ASSERT(key.tzID != NULL && key.mzID != NULL); | |
| const UChar* uplname = (const UChar*)uhash_get(fPartialLocationNamesMap, (void *)&key); | |
| if (uplname != NULL) { | |
| return uplname; | |
| } | |
| UnicodeString location; | |
| UnicodeString usCountryCode; | |
| ZoneMeta::getCanonicalCountry(tzCanonicalID, usCountryCode); | |
| if (!usCountryCode.isEmpty()) { | |
| char countryCode[ULOC_COUNTRY_CAPACITY]; | |
| U_ASSERT(usCountryCode.length() < ULOC_COUNTRY_CAPACITY); | |
| int32_t ccLen = usCountryCode.extract(0, usCountryCode.length(), countryCode, sizeof(countryCode), US_INV); | |
| countryCode[ccLen] = 0; | |
| UnicodeString regionalGolden; | |
| fTimeZoneNames->getReferenceZoneID(mzID, countryCode, regionalGolden); | |
| if (tzCanonicalID == regionalGolden) { | |
| // Use country name | |
| fLocaleDisplayNames->regionDisplayName(countryCode, location); | |
| } else { | |
| // Otherwise, use exemplar city name | |
| fTimeZoneNames->getExemplarLocationName(tzCanonicalID, location); | |
| } | |
| } else { | |
| fTimeZoneNames->getExemplarLocationName(tzCanonicalID, location); | |
| if (location.isEmpty()) { | |
| // This could happen when the time zone is not associated with a country, | |
| // and its ID is not hierarchical, for example, CST6CDT. | |
| // We use the canonical ID itself as the location for this case. | |
| location.setTo(tzCanonicalID); | |
| } | |
| } | |
| UErrorCode status = U_ZERO_ERROR; | |
| UnicodeString name; | |
| FieldPosition fpos; | |
| Formattable param[] = { | |
| Formattable(location), | |
| Formattable(mzDisplayName) | |
| }; | |
| fFallbackFormat->format(param, 2, name, fpos, status); | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| uplname = fStringPool.get(name, status); | |
| if (U_SUCCESS(status)) { | |
| // Add the name to cache | |
| PartialLocationKey* cacheKey = (PartialLocationKey *)uprv_malloc(sizeof(PartialLocationKey)); | |
| if (cacheKey != NULL) { | |
| cacheKey->tzID = key.tzID; | |
| cacheKey->mzID = key.mzID; | |
| cacheKey->isLong = key.isLong; | |
| uhash_put(fPartialLocationNamesMap, (void *)cacheKey, (void *)uplname, &status); | |
| if (U_FAILURE(status)) { | |
| uprv_free(cacheKey); | |
| } else { | |
| // put the name to the local trie as well | |
| GNameInfo *nameinfo = (ZNameInfo *)uprv_malloc(sizeof(GNameInfo)); | |
| if (nameinfo != NULL) { | |
| nameinfo->type = isLong ? UTZGNM_LONG : UTZGNM_SHORT; | |
| nameinfo->tzID = key.tzID; | |
| fGNamesTrie.put(uplname, nameinfo, status); | |
| } | |
| } | |
| } | |
| } | |
| return uplname; | |
| } | |
| /* | |
| * This method updates the cache and must be called with a lock, | |
| * except initializer. | |
| */ | |
| void | |
| TZGNCore::loadStrings(const UnicodeString& tzCanonicalID) { | |
| // load the generic location name | |
| getGenericLocationName(tzCanonicalID); | |
| // partial location names | |
| UErrorCode status = U_ZERO_ERROR; | |
| const UnicodeString *mzID; | |
| UnicodeString goldenID; | |
| UnicodeString mzGenName; | |
| UTimeZoneNameType genNonLocTypes[] = { | |
| UTZNM_LONG_GENERIC, UTZNM_SHORT_GENERIC, | |
| UTZNM_UNKNOWN /*terminator*/ | |
| }; | |
| StringEnumeration *mzIDs = fTimeZoneNames->getAvailableMetaZoneIDs(tzCanonicalID, status); | |
| while ((mzID = mzIDs->snext(status))) { | |
| if (U_FAILURE(status)) { | |
| break; | |
| } | |
| // if this time zone is not the golden zone of the meta zone, | |
| // partial location name (such as "PT (Los Angeles)") might be | |
| // available. | |
| fTimeZoneNames->getReferenceZoneID(*mzID, fTargetRegion, goldenID); | |
| if (tzCanonicalID != goldenID) { | |
| for (int32_t i = 0; genNonLocTypes[i] != UTZNM_UNKNOWN; i++) { | |
| fTimeZoneNames->getMetaZoneDisplayName(*mzID, genNonLocTypes[i], mzGenName); | |
| if (!mzGenName.isEmpty()) { | |
| // getPartialLocationName formats a name and put it into the trie | |
| getPartialLocationName(tzCanonicalID, *mzID, | |
| (genNonLocTypes[i] == UTZNM_LONG_GENERIC), mzGenName); | |
| } | |
| } | |
| } | |
| } | |
| if (mzIDs != NULL) { | |
| delete mzIDs; | |
| } | |
| } | |
| int32_t | |
| TZGNCore::findBestMatch(const UnicodeString& text, int32_t start, uint32_t types, | |
| UnicodeString& tzID, UTimeZoneFormatTimeType& timeType, UErrorCode& status) const { | |
| timeType = UTZFMT_TIME_TYPE_UNKNOWN; | |
| tzID.setToBogus(); | |
| if (U_FAILURE(status)) { | |
| return 0; | |
| } | |
| // Find matches in the TimeZoneNames first | |
| TimeZoneNames::MatchInfoCollection *tznamesMatches = findTimeZoneNames(text, start, types, status); | |
| if (U_FAILURE(status)) { | |
| return 0; | |
| } | |
| int32_t bestMatchLen = 0; | |
| UTimeZoneFormatTimeType bestMatchTimeType = UTZFMT_TIME_TYPE_UNKNOWN; | |
| UnicodeString bestMatchTzID; | |
| // UBool isLongStandard = FALSE; // workaround - see the comments below | |
| 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 | |
| if (tznamesMatches != NULL) { | |
| UnicodeString mzID; | |
| for (int32_t i = 0; i < tznamesMatches->size(); i++) { | |
| int32_t len = tznamesMatches->getMatchLengthAt(i); | |
| if (len > bestMatchLen) { | |
| bestMatchLen = len; | |
| if (!tznamesMatches->getTimeZoneIDAt(i, bestMatchTzID)) { | |
| // name for a meta zone | |
| if (tznamesMatches->getMetaZoneIDAt(i, mzID)) { | |
| fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, bestMatchTzID); | |
| } | |
| } | |
| UTimeZoneNameType nameType = tznamesMatches->getNameTypeAt(i); | |
| if (U_FAILURE(status)) { | |
| break; | |
| } | |
| switch (nameType) { | |
| case UTZNM_LONG_STANDARD: | |
| // isLongStandard = TRUE; | |
| case UTZNM_SHORT_STANDARD: // this one is never used for generic, but just in case | |
| isStandard = TRUE; // TODO: Remove this later, see the comments above. | |
| bestMatchTimeType = UTZFMT_TIME_TYPE_STANDARD; | |
| break; | |
| case UTZNM_LONG_DAYLIGHT: | |
| case UTZNM_SHORT_DAYLIGHT: // this one is never used for generic, but just in case | |
| bestMatchTimeType = UTZFMT_TIME_TYPE_DAYLIGHT; | |
| break; | |
| default: | |
| bestMatchTimeType = UTZFMT_TIME_TYPE_UNKNOWN; | |
| } | |
| } | |
| } | |
| delete tznamesMatches; | |
| if (U_FAILURE(status)) { | |
| return 0; | |
| } | |
| if (bestMatchLen == (text.length() - start)) { | |
| // Full match | |
| //tzID.setTo(bestMatchTzID); | |
| //timeType = bestMatchTimeType; | |
| //return bestMatchLen; | |
| // TODO Some time zone uses a same name for the long standard name | |
| // and the location name. When the match is a long standard name, | |
| // then we need to check if the name is same with the location name. | |
| // This is probably a data error or a design bug. | |
| /* | |
| if (!isLongStandard) { | |
| tzID.setTo(bestMatchTzID); | |
| timeType = bestMatchTimeType; | |
| return bestMatchLen; | |
| } | |
| */ | |
| // TODO The deprecation of commonlyUsed flag introduced the name | |
| // conflict not only for long standard names, but short standard names too. | |
| // These short names (found in zh_Hant) should be gone once we clean | |
| // up CLDR time zone display name data. Once the short name conflict | |
| // problem (with location name) is resolved, we should change the condition | |
| // below back to the original one above. -Yoshito (2011-09-14) | |
| if (!isStandard) { | |
| tzID.setTo(bestMatchTzID); | |
| timeType = bestMatchTimeType; | |
| return bestMatchLen; | |
| } | |
| } | |
| } | |
| // Find matches in the local trie | |
| TimeZoneGenericNameMatchInfo *localMatches = findLocal(text, start, types, status); | |
| if (U_FAILURE(status)) { | |
| return 0; | |
| } | |
| if (localMatches != NULL) { | |
| for (int32_t i = 0; i < localMatches->size(); i++) { | |
| int32_t len = localMatches->getMatchLength(i); | |
| // TODO See the above TODO. We use len >= bestMatchLen | |
| // because of the long standard/location name collision | |
| // problem. If it is also a location name, carrying | |
| // timeType = UTZFMT_TIME_TYPE_STANDARD will cause a | |
| // problem in SimpleDateFormat | |
| if (len >= bestMatchLen) { | |
| bestMatchLen = localMatches->getMatchLength(i); | |
| bestMatchTimeType = UTZFMT_TIME_TYPE_UNKNOWN; // because generic | |
| localMatches->getTimeZoneID(i, bestMatchTzID); | |
| } | |
| } | |
| delete localMatches; | |
| } | |
| if (bestMatchLen > 0) { | |
| timeType = bestMatchTimeType; | |
| tzID.setTo(bestMatchTzID); | |
| } | |
| return bestMatchLen; | |
| } | |
| TimeZoneGenericNameMatchInfo* | |
| TZGNCore::findLocal(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const { | |
| GNameSearchHandler handler(types); | |
| TZGNCore *nonConstThis = const_cast<TZGNCore *>(this); | |
| umtx_lock(&gLock); | |
| { | |
| fGNamesTrie.search(text, start, (TextTrieMapSearchResultHandler *)&handler, status); | |
| } | |
| umtx_unlock(&gLock); | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| TimeZoneGenericNameMatchInfo *gmatchInfo = NULL; | |
| int32_t maxLen = 0; | |
| UVector *results = handler.getMatches(maxLen); | |
| if (results != NULL && ((maxLen == (text.length() - start)) || fGNamesTrieFullyLoaded)) { | |
| // perfect match | |
| gmatchInfo = new TimeZoneGenericNameMatchInfo(results); | |
| if (gmatchInfo == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| delete results; | |
| return NULL; | |
| } | |
| return gmatchInfo; | |
| } | |
| if (results != NULL) { | |
| delete results; | |
| } | |
| // All names are not yet loaded into the local trie. | |
| // Load all available names into the trie. This could be very heavy. | |
| umtx_lock(&gLock); | |
| { | |
| if (!fGNamesTrieFullyLoaded) { | |
| StringEnumeration *tzIDs = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL, NULL, NULL, status); | |
| if (U_SUCCESS(status)) { | |
| const UnicodeString *tzID; | |
| while ((tzID = tzIDs->snext(status))) { | |
| if (U_FAILURE(status)) { | |
| break; | |
| } | |
| nonConstThis->loadStrings(*tzID); | |
| } | |
| } | |
| if (tzIDs != NULL) { | |
| delete tzIDs; | |
| } | |
| if (U_SUCCESS(status)) { | |
| nonConstThis->fGNamesTrieFullyLoaded = TRUE; | |
| } | |
| } | |
| } | |
| umtx_unlock(&gLock); | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| umtx_lock(&gLock); | |
| { | |
| // now try it again | |
| fGNamesTrie.search(text, start, (TextTrieMapSearchResultHandler *)&handler, status); | |
| } | |
| umtx_unlock(&gLock); | |
| results = handler.getMatches(maxLen); | |
| if (results != NULL && maxLen > 0) { | |
| gmatchInfo = new TimeZoneGenericNameMatchInfo(results); | |
| if (gmatchInfo == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| delete results; | |
| return NULL; | |
| } | |
| } | |
| return gmatchInfo; | |
| } | |
| TimeZoneNames::MatchInfoCollection* | |
| TZGNCore::findTimeZoneNames(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const { | |
| // Check if the target name typs is really in the TimeZoneNames | |
| uint32_t nameTypes = 0; | |
| if (types & UTZGNM_LONG) { | |
| nameTypes |= (UTZNM_LONG_GENERIC | UTZNM_LONG_STANDARD); | |
| } | |
| if (types & UTZGNM_SHORT) { | |
| nameTypes |= (UTZNM_SHORT_GENERIC | UTZNM_SHORT_STANDARD); | |
| } | |
| if (types) { | |
| // Find matches in the TimeZoneNames | |
| return fTimeZoneNames->find(text, start, nameTypes, status); | |
| } | |
| return NULL; | |
| } | |
| typedef struct TZGNCoreRef { | |
| TZGNCore* obj; | |
| int32_t refCount; | |
| double lastAccess; | |
| } TZGNCoreRef; | |
| // TZGNCore object cache handling | |
| static UMutex gTZGNLock = U_MUTEX_INITIALIZER; | |
| static UHashtable *gTZGNCoreCache = NULL; | |
| static UBool gTZGNCoreCacheInitialized = 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 | |
| U_CDECL_BEGIN | |
| /** | |
| * Cleanup callback func | |
| */ | |
| static UBool U_CALLCONV tzgnCore_cleanup(void) | |
| { | |
| if (gTZGNCoreCache != NULL) { | |
| uhash_close(gTZGNCoreCache); | |
| gTZGNCoreCache = NULL; | |
| } | |
| gTZGNCoreCacheInitialized = FALSE; | |
| return TRUE; | |
| } | |
| /** | |
| * Deleter for TZGNCoreRef | |
| */ | |
| static void U_CALLCONV | |
| deleteTZGNCoreRef(void *obj) { | |
| icu::TZGNCoreRef *entry = (icu::TZGNCoreRef*)obj; | |
| delete (icu::TZGNCore*) entry->obj; | |
| 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(gTZGNCoreCache, &pos))) { | |
| TZGNCoreRef *entry = (TZGNCoreRef *)elem->value.pointer; | |
| if (entry->refCount <= 0 && (now - entry->lastAccess) > CACHE_EXPIRATION) { | |
| // delete this entry | |
| uhash_removeElement(gTZGNCoreCache, elem); | |
| } | |
| } | |
| } | |
| TimeZoneGenericNames::TimeZoneGenericNames() | |
| : fRef(0) { | |
| } | |
| TimeZoneGenericNames::~TimeZoneGenericNames() { | |
| umtx_lock(&gTZGNLock); | |
| { | |
| U_ASSERT(fRef->refCount > 0); | |
| // Just decrement the reference count | |
| fRef->refCount--; | |
| } | |
| umtx_unlock(&gTZGNLock); | |
| } | |
| TimeZoneGenericNames* | |
| TimeZoneGenericNames::createInstance(const Locale& locale, UErrorCode& status) { | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| TimeZoneGenericNames* instance = new TimeZoneGenericNames(); | |
| if (instance == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return NULL; | |
| } | |
| TZGNCoreRef *cacheEntry = NULL; | |
| { | |
| Mutex lock(&gTZGNLock); | |
| if (!gTZGNCoreCacheInitialized) { | |
| // Create empty hashtable | |
| gTZGNCoreCache = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status); | |
| if (U_SUCCESS(status)) { | |
| uhash_setKeyDeleter(gTZGNCoreCache, uprv_free); | |
| uhash_setValueDeleter(gTZGNCoreCache, deleteTZGNCoreRef); | |
| gTZGNCoreCacheInitialized = TRUE; | |
| ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONEGENERICNAMES, tzgnCore_cleanup); | |
| } | |
| } | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| // Check the cache, if not available, create new one and cache | |
| const char *key = locale.getName(); | |
| cacheEntry = (TZGNCoreRef *)uhash_get(gTZGNCoreCache, key); | |
| if (cacheEntry == NULL) { | |
| TZGNCore *tzgnCore = NULL; | |
| char *newKey = NULL; | |
| tzgnCore = new TZGNCore(locale, status); | |
| if (tzgnCore == 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 = (TZGNCoreRef *)uprv_malloc(sizeof(TZGNCoreRef)); | |
| if (cacheEntry == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| } else { | |
| cacheEntry->obj = tzgnCore; | |
| cacheEntry->refCount = 1; | |
| cacheEntry->lastAccess = (double)uprv_getUTCtime(); | |
| uhash_put(gTZGNCoreCache, newKey, cacheEntry, &status); | |
| } | |
| } | |
| if (U_FAILURE(status)) { | |
| if (tzgnCore != NULL) { | |
| delete tzgnCore; | |
| } | |
| 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; | |
| } | |
| } // End of mutex locked block | |
| if (cacheEntry == NULL) { | |
| delete instance; | |
| return NULL; | |
| } | |
| instance->fRef = cacheEntry; | |
| return instance; | |
| } | |
| UBool | |
| TimeZoneGenericNames::operator==(const TimeZoneGenericNames& other) const { | |
| // Just compare if the other object also use the same | |
| // ref entry | |
| return fRef == other.fRef; | |
| } | |
| TimeZoneGenericNames* | |
| TimeZoneGenericNames::clone() const { | |
| TimeZoneGenericNames* other = new TimeZoneGenericNames(); | |
| if (other) { | |
| umtx_lock(&gTZGNLock); | |
| { | |
| // Just increments the reference count | |
| fRef->refCount++; | |
| other->fRef = fRef; | |
| } | |
| umtx_unlock(&gTZGNLock); | |
| } | |
| return other; | |
| } | |
| UnicodeString& | |
| TimeZoneGenericNames::getDisplayName(const TimeZone& tz, UTimeZoneGenericNameType type, | |
| UDate date, UnicodeString& name) const { | |
| return fRef->obj->getDisplayName(tz, type, date, name); | |
| } | |
| UnicodeString& | |
| TimeZoneGenericNames::getGenericLocationName(const UnicodeString& tzCanonicalID, UnicodeString& name) const { | |
| return fRef->obj->getGenericLocationName(tzCanonicalID, name); | |
| } | |
| int32_t | |
| TimeZoneGenericNames::findBestMatch(const UnicodeString& text, int32_t start, uint32_t types, | |
| UnicodeString& tzID, UTimeZoneFormatTimeType& timeType, UErrorCode& status) const { | |
| return fRef->obj->findBestMatch(text, start, types, tzID, timeType, status); | |
| } | |
| U_NAMESPACE_END | |
| #endif |