fix ya.make

1 files changed, 1330 insertions, 0 deletions

diff --git a/contrib/libs/icu/i18n/tzgnames.cpp b/contrib/libs/icu/i18n/tzgnames.cpp
new file mode 100644
index 0000000000..e056461dc3
--- /dev/null
+++ b/contrib/libs/icu/i18n/tzgnames.cpp
@@ -0,0 +1,1330 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+/*
+*******************************************************************************
+* Copyright (C) 2011-2016, International Business Machines Corporation and
+* others. All Rights Reserved.
+*******************************************************************************
+*/
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "tzgnames.h"
+
+#include "unicode/basictz.h"
+#include "unicode/locdspnm.h"
+#include "unicode/rbtz.h"
+#include "unicode/simpleformatter.h"
+#include "unicode/simpletz.h"
+#include "unicode/strenum.h"
+#include "unicode/vtzone.h"
+
+#include "bytesinkutil.h"
+#include "charstr.h"
+#include "cmemory.h"
+#include "cstring.h"
+#include "mutex.h"
+#include "uhash.h"
+#include "uassert.h"
+#include "umutex.h"
+#include "ulocimp.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;
+
+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;
+
+    SimpleFormatter fRegionFormat;
+    SimpleFormatter 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),
+  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.applyPatternMinMaxArguments(rpat, 1, 1, status);
+    fFallbackFormat.applyPatternMinMaxArguments(fpat, 2, 2, status);
+    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 = static_cast<int32_t>(uprv_strlen(region));
+    if (regionLen == 0) {
+        CharString loc;
+        {
+            CharStringByteSink sink(&loc);
+            ulocimp_addLikelySubtags(fLocale.getName(), sink, &status);
+        }
+
+        regionLen = uloc_getCountry(loc.data(), 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 (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()) {
+        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);
+            fRegionFormat.format(country, name, 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);
+            fRegionFormat.format(city, name, 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[ZONE_NAME_U16_MAX];
+
+        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[ZONE_NAME_U16_MAX];
+                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;
+    fFallbackFormat.format(location, mzDisplayName, name, 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)) != NULL) {
+        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)) != NULL) {
+                    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;
+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)) != NULL) {
+        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