diff options
Diffstat (limited to 'intl/icu/source/i18n/zonemeta.cpp')
| -rw-r--r-- | intl/icu/source/i18n/zonemeta.cpp | 928 |
1 files changed, 928 insertions, 0 deletions
diff --git a/intl/icu/source/i18n/zonemeta.cpp b/intl/icu/source/i18n/zonemeta.cpp new file mode 100644 index 0000000000..42051e2f41 --- /dev/null +++ b/intl/icu/source/i18n/zonemeta.cpp @@ -0,0 +1,928 @@ +// © 2016 and later: Unicode, Inc. and others. +// License & terms of use: http://www.unicode.org/copyright.html +/* +******************************************************************************* +* Copyright (C) 2007-2014, International Business Machines Corporation and +* others. All Rights Reserved. +******************************************************************************* +*/ + +#include "unicode/utypes.h" + +#if !UCONFIG_NO_FORMATTING + +#include "zonemeta.h" + +#include "unicode/timezone.h" +#include "unicode/ustring.h" +#include "unicode/putil.h" +#include "unicode/simpletz.h" +#include "unicode/strenum.h" +#include "umutex.h" +#include "uvector.h" +#include "cmemory.h" +#include "gregoimp.h" +#include "cstring.h" +#include "ucln_in.h" +#include "uassert.h" +#include "uresimp.h" +#include "uhash.h" +#include "olsontz.h" +#include "uinvchar.h" + +static icu::UMutex gZoneMetaLock; + +// CLDR Canonical ID mapping table +static UHashtable *gCanonicalIDCache = nullptr; +static icu::UInitOnce gCanonicalIDCacheInitOnce {}; + +// Metazone mapping table +static UHashtable *gOlsonToMeta = nullptr; +static icu::UInitOnce gOlsonToMetaInitOnce {}; + +// Available metazone IDs vector and table +static icu::UVector *gMetaZoneIDs = nullptr; +static UHashtable *gMetaZoneIDTable = nullptr; +static icu::UInitOnce gMetaZoneIDsInitOnce {}; + +// Country info vectors +static icu::UVector *gSingleZoneCountries = nullptr; +static icu::UVector *gMultiZonesCountries = nullptr; +static icu::UInitOnce gCountryInfoVectorsInitOnce {}; + +U_CDECL_BEGIN + +/** + * Cleanup callback func + */ +static UBool U_CALLCONV zoneMeta_cleanup() +{ + if (gCanonicalIDCache != nullptr) { + uhash_close(gCanonicalIDCache); + gCanonicalIDCache = nullptr; + } + gCanonicalIDCacheInitOnce.reset(); + + if (gOlsonToMeta != nullptr) { + uhash_close(gOlsonToMeta); + gOlsonToMeta = nullptr; + } + gOlsonToMetaInitOnce.reset(); + + if (gMetaZoneIDTable != nullptr) { + uhash_close(gMetaZoneIDTable); + gMetaZoneIDTable = nullptr; + } + // delete after closing gMetaZoneIDTable, because it holds + // value objects held by the hashtable + delete gMetaZoneIDs; + gMetaZoneIDs = nullptr; + gMetaZoneIDsInitOnce.reset(); + + delete gSingleZoneCountries; + gSingleZoneCountries = nullptr; + delete gMultiZonesCountries; + gMultiZonesCountries = nullptr; + gCountryInfoVectorsInitOnce.reset(); + + return true; +} + +/** + * Deleter for char16_t* string + */ +static void U_CALLCONV +deleteUCharString(void *obj) { + char16_t *entry = (char16_t*)obj; + uprv_free(entry); +} + +/** + * Deleter for OlsonToMetaMappingEntry + */ +static void U_CALLCONV +deleteOlsonToMetaMappingEntry(void *obj) { + icu::OlsonToMetaMappingEntry *entry = (icu::OlsonToMetaMappingEntry*)obj; + delete entry; +} + +U_CDECL_END + +U_NAMESPACE_BEGIN + +#define ZID_KEY_MAX 128 + +static const char gMetaZones[] = "metaZones"; +static const char gMetazoneInfo[] = "metazoneInfo"; +static const char gMapTimezonesTag[] = "mapTimezones"; + +static const char gKeyTypeData[] = "keyTypeData"; +static const char gTypeAliasTag[] = "typeAlias"; +static const char gTypeMapTag[] = "typeMap"; +static const char gTimezoneTag[] = "timezone"; + +static const char gPrimaryZonesTag[] = "primaryZones"; + +static const char gWorldTag[] = "001"; + +static const char16_t gWorld[] = {0x30, 0x30, 0x31, 0x00}; // "001" + +static const char16_t gDefaultFrom[] = {0x31, 0x39, 0x37, 0x30, 0x2D, 0x30, 0x31, 0x2D, 0x30, 0x31, + 0x20, 0x30, 0x30, 0x3A, 0x30, 0x30, 0x00}; // "1970-01-01 00:00" +static const char16_t gDefaultTo[] = {0x39, 0x39, 0x39, 0x39, 0x2D, 0x31, 0x32, 0x2D, 0x33, 0x31, + 0x20, 0x32, 0x33, 0x3A, 0x35, 0x39, 0x00}; // "9999-12-31 23:59" + +static const char16_t gCustomTzPrefix[] = {0x47, 0x4D, 0x54, 0}; // "GMT" + +#define ASCII_DIGIT(c) (((c)>=0x30 && (c)<=0x39) ? (c)-0x30 : -1) + +/* + * Convert a date string used by metazone mappings to UDate. + * The format used by CLDR metazone mapping is "yyyy-MM-dd HH:mm". + */ +static UDate +parseDate (const char16_t *text, UErrorCode &status) { + if (U_FAILURE(status)) { + return 0; + } + int32_t len = u_strlen(text); + if (len != 16 && len != 10) { + // It must be yyyy-MM-dd HH:mm (length 16) or yyyy-MM-dd (length 10) + status = U_INVALID_FORMAT_ERROR; + return 0; + } + + int32_t year = 0, month = 0, day = 0, hour = 0, min = 0, n; + int32_t idx; + + // "yyyy" (0 - 3) + for (idx = 0; idx <= 3 && U_SUCCESS(status); idx++) { + n = ASCII_DIGIT((int32_t)text[idx]); + if (n >= 0) { + year = 10*year + n; + } else { + status = U_INVALID_FORMAT_ERROR; + } + } + // "MM" (5 - 6) + for (idx = 5; idx <= 6 && U_SUCCESS(status); idx++) { + n = ASCII_DIGIT((int32_t)text[idx]); + if (n >= 0) { + month = 10*month + n; + } else { + status = U_INVALID_FORMAT_ERROR; + } + } + // "dd" (8 - 9) + for (idx = 8; idx <= 9 && U_SUCCESS(status); idx++) { + n = ASCII_DIGIT((int32_t)text[idx]); + if (n >= 0) { + day = 10*day + n; + } else { + status = U_INVALID_FORMAT_ERROR; + } + } + if (len == 16) { + // "HH" (11 - 12) + for (idx = 11; idx <= 12 && U_SUCCESS(status); idx++) { + n = ASCII_DIGIT((int32_t)text[idx]); + if (n >= 0) { + hour = 10*hour + n; + } else { + status = U_INVALID_FORMAT_ERROR; + } + } + // "mm" (14 - 15) + for (idx = 14; idx <= 15 && U_SUCCESS(status); idx++) { + n = ASCII_DIGIT((int32_t)text[idx]); + if (n >= 0) { + min = 10*min + n; + } else { + status = U_INVALID_FORMAT_ERROR; + } + } + } + + if (U_SUCCESS(status)) { + UDate date = Grego::fieldsToDay(year, month - 1, day) * U_MILLIS_PER_DAY + + hour * U_MILLIS_PER_HOUR + min * U_MILLIS_PER_MINUTE; + return date; + } + return 0; +} + +static void U_CALLCONV initCanonicalIDCache(UErrorCode &status) { + gCanonicalIDCache = uhash_open(uhash_hashUChars, uhash_compareUChars, nullptr, &status); + if (gCanonicalIDCache == nullptr) { + status = U_MEMORY_ALLOCATION_ERROR; + } + if (U_FAILURE(status)) { + gCanonicalIDCache = nullptr; + } + // No key/value deleters - keys/values are from a resource bundle + ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup); +} + + +const char16_t* U_EXPORT2 +ZoneMeta::getCanonicalCLDRID(const UnicodeString &tzid, UErrorCode& status) { + if (U_FAILURE(status)) { + return nullptr; + } + + if (tzid.isBogus() || tzid.length() > ZID_KEY_MAX) { + status = U_ILLEGAL_ARGUMENT_ERROR; + return nullptr; + } + + // Checking the cached results + umtx_initOnce(gCanonicalIDCacheInitOnce, &initCanonicalIDCache, status); + if (U_FAILURE(status)) { + return nullptr; + } + + const char16_t *canonicalID = nullptr; + + UErrorCode tmpStatus = U_ZERO_ERROR; + char16_t utzid[ZID_KEY_MAX + 1]; + tzid.extract(utzid, ZID_KEY_MAX + 1, tmpStatus); + U_ASSERT(tmpStatus == U_ZERO_ERROR); // we checked the length of tzid already + + if (!uprv_isInvariantUString(utzid, -1)) { + // All of known tz IDs are only containing ASCII invariant characters. + status = U_ILLEGAL_ARGUMENT_ERROR; + return nullptr; + } + + // Check if it was already cached + umtx_lock(&gZoneMetaLock); + { + canonicalID = (const char16_t *)uhash_get(gCanonicalIDCache, utzid); + } + umtx_unlock(&gZoneMetaLock); + + if (canonicalID != nullptr) { + return canonicalID; + } + + // If not, resolve CLDR canonical ID with resource data + UBool isInputCanonical = false; + char id[ZID_KEY_MAX + 1]; + tzid.extract(0, 0x7fffffff, id, UPRV_LENGTHOF(id), US_INV); + + // replace '/' with ':' + char *p = id; + while (*p++) { + if (*p == '/') { + *p = ':'; + } + } + + UResourceBundle *top = ures_openDirect(nullptr, gKeyTypeData, &tmpStatus); + UResourceBundle *rb = ures_getByKey(top, gTypeMapTag, nullptr, &tmpStatus); + ures_getByKey(rb, gTimezoneTag, rb, &tmpStatus); + ures_getByKey(rb, id, rb, &tmpStatus); + if (U_SUCCESS(tmpStatus)) { + // type entry (canonical) found + // the input is the canonical ID. resolve to const char16_t* + canonicalID = TimeZone::findID(tzid); + isInputCanonical = true; + } + + if (canonicalID == nullptr) { + // If a map element not found, then look for an alias + tmpStatus = U_ZERO_ERROR; + ures_getByKey(top, gTypeAliasTag, rb, &tmpStatus); + ures_getByKey(rb, gTimezoneTag, rb, &tmpStatus); + const char16_t *canonical = ures_getStringByKey(rb,id,nullptr,&tmpStatus); + if (U_SUCCESS(tmpStatus)) { + // canonical map found + canonicalID = canonical; + } + + if (canonicalID == nullptr) { + // Dereference the input ID using the tz data + const char16_t *derefer = TimeZone::dereferOlsonLink(tzid); + if (derefer == nullptr) { + status = U_ILLEGAL_ARGUMENT_ERROR; + } else { + int32_t len = u_strlen(derefer); + u_UCharsToChars(derefer,id,len); + id[len] = (char) 0; // Make sure it is null terminated. + + // replace '/' with ':' + char *q = id; + while (*q++) { + if (*q == '/') { + *q = ':'; + } + } + + // If a dereference turned something up then look for an alias. + // rb still points to the alias table, so we don't have to go looking + // for it. + tmpStatus = U_ZERO_ERROR; + canonical = ures_getStringByKey(rb,id,nullptr,&tmpStatus); + if (U_SUCCESS(tmpStatus)) { + // canonical map for the dereferenced ID found + canonicalID = canonical; + } else { + canonicalID = derefer; + isInputCanonical = true; + } + } + } + } + ures_close(rb); + ures_close(top); + + if (U_SUCCESS(status)) { + U_ASSERT(canonicalID != nullptr); // canocanilD must be non-nullptr here + + // Put the resolved canonical ID to the cache + umtx_lock(&gZoneMetaLock); + { + const char16_t* idInCache = (const char16_t *)uhash_get(gCanonicalIDCache, utzid); + if (idInCache == nullptr) { + const char16_t* key = ZoneMeta::findTimeZoneID(tzid); + U_ASSERT(key != nullptr); + if (key != nullptr) { + idInCache = (const char16_t *)uhash_put(gCanonicalIDCache, (void *)key, (void *)canonicalID, &status); + U_ASSERT(idInCache == nullptr); + } + } + if (U_SUCCESS(status) && isInputCanonical) { + // Also put canonical ID itself into the cache if not exist + const char16_t *canonicalInCache = (const char16_t*)uhash_get(gCanonicalIDCache, canonicalID); + if (canonicalInCache == nullptr) { + canonicalInCache = (const char16_t *)uhash_put(gCanonicalIDCache, (void *)canonicalID, (void *)canonicalID, &status); + U_ASSERT(canonicalInCache == nullptr); + } + } + } + umtx_unlock(&gZoneMetaLock); + } + + return canonicalID; +} + +UnicodeString& U_EXPORT2 +ZoneMeta::getCanonicalCLDRID(const UnicodeString &tzid, UnicodeString &systemID, UErrorCode& status) { + const char16_t *canonicalID = getCanonicalCLDRID(tzid, status); + if (U_FAILURE(status) || canonicalID == nullptr) { + systemID.setToBogus(); + return systemID; + } + systemID.setTo(true, canonicalID, -1); + return systemID; +} + +const char16_t* U_EXPORT2 +ZoneMeta::getCanonicalCLDRID(const TimeZone& tz) { + if (dynamic_cast<const OlsonTimeZone *>(&tz) != nullptr) { + // short cut for OlsonTimeZone + const OlsonTimeZone *otz = (const OlsonTimeZone*)&tz; + return otz->getCanonicalID(); + } + UErrorCode status = U_ZERO_ERROR; + UnicodeString tzID; + return getCanonicalCLDRID(tz.getID(tzID), status); +} + +static void U_CALLCONV countryInfoVectorsInit(UErrorCode &status) { + // Create empty vectors + // No deleters for these UVectors, it's a reference to a resource bundle string. + gSingleZoneCountries = new UVector(nullptr, uhash_compareUChars, status); + if (gSingleZoneCountries == nullptr) { + status = U_MEMORY_ALLOCATION_ERROR; + } + gMultiZonesCountries = new UVector(nullptr, uhash_compareUChars, status); + if (gMultiZonesCountries == nullptr) { + status = U_MEMORY_ALLOCATION_ERROR; + } + + if (U_FAILURE(status)) { + delete gSingleZoneCountries; + delete gMultiZonesCountries; + gSingleZoneCountries = nullptr; + gMultiZonesCountries = nullptr; + } + ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup); +} + + +UnicodeString& U_EXPORT2 +ZoneMeta::getCanonicalCountry(const UnicodeString &tzid, UnicodeString &country, UBool *isPrimary /* = nullptr */) { + if (isPrimary != nullptr) { + *isPrimary = false; + } + + const char16_t *region = TimeZone::getRegion(tzid); + if (region != nullptr && u_strcmp(gWorld, region) != 0) { + country.setTo(region, -1); + } else { + country.setToBogus(); + return country; + } + + if (isPrimary != nullptr) { + char regionBuf[] = {0, 0, 0}; + + // Checking the cached results + UErrorCode status = U_ZERO_ERROR; + umtx_initOnce(gCountryInfoVectorsInitOnce, &countryInfoVectorsInit, status); + if (U_FAILURE(status)) { + return country; + } + + // Check if it was already cached + UBool cached = false; + UBool singleZone = false; + umtx_lock(&gZoneMetaLock); + { + singleZone = cached = gSingleZoneCountries->contains((void*)region); + if (!cached) { + cached = gMultiZonesCountries->contains((void*)region); + } + } + umtx_unlock(&gZoneMetaLock); + + if (!cached) { + // We need to go through all zones associated with the region. + // This is relatively heavy operation. + + U_ASSERT(u_strlen(region) == 2); + + u_UCharsToChars(region, regionBuf, 2); + + StringEnumeration *ids = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL_LOCATION, regionBuf, nullptr, status); + int32_t idsLen = ids->count(status); + if (U_SUCCESS(status) && idsLen == 1) { + // only the single zone is available for the region + singleZone = true; + } + delete ids; + + // Cache the result + umtx_lock(&gZoneMetaLock); + { + UErrorCode ec = U_ZERO_ERROR; + if (singleZone) { + if (!gSingleZoneCountries->contains((void*)region)) { + gSingleZoneCountries->addElement((void*)region, ec); + } + } else { + if (!gMultiZonesCountries->contains((void*)region)) { + gMultiZonesCountries->addElement((void*)region, ec); + } + } + } + umtx_unlock(&gZoneMetaLock); + } + + if (singleZone) { + *isPrimary = true; + } else { + // Note: We may cache the primary zone map in future. + + // Even a country has multiple zones, one of them might be + // dominant and treated as a primary zone + int32_t idLen = 0; + if (regionBuf[0] == 0) { + u_UCharsToChars(region, regionBuf, 2); + } + + UResourceBundle *rb = ures_openDirect(nullptr, gMetaZones, &status); + ures_getByKey(rb, gPrimaryZonesTag, rb, &status); + const char16_t *primaryZone = ures_getStringByKey(rb, regionBuf, &idLen, &status); + if (U_SUCCESS(status)) { + if (tzid.compare(primaryZone, idLen) == 0) { + *isPrimary = true; + } else { + // The given ID might not be a canonical ID + UnicodeString canonicalID; + TimeZone::getCanonicalID(tzid, canonicalID, status); + if (U_SUCCESS(status) && canonicalID.compare(primaryZone, idLen) == 0) { + *isPrimary = true; + } + } + } + ures_close(rb); + } + } + + return country; +} + +UnicodeString& U_EXPORT2 +ZoneMeta::getMetazoneID(const UnicodeString &tzid, UDate date, UnicodeString &result) { + UBool isSet = false; + const UVector *mappings = getMetazoneMappings(tzid); + if (mappings != nullptr) { + for (int32_t i = 0; i < mappings->size(); i++) { + OlsonToMetaMappingEntry *mzm = (OlsonToMetaMappingEntry*)mappings->elementAt(i); + if (mzm->from <= date && mzm->to > date) { + result.setTo(mzm->mzid, -1); + isSet = true; + break; + } + } + } + if (!isSet) { + result.setToBogus(); + } + return result; +} + +static void U_CALLCONV olsonToMetaInit(UErrorCode &status) { + U_ASSERT(gOlsonToMeta == nullptr); + ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup); + gOlsonToMeta = uhash_open(uhash_hashUChars, uhash_compareUChars, nullptr, &status); + if (U_FAILURE(status)) { + gOlsonToMeta = nullptr; + } else { + uhash_setKeyDeleter(gOlsonToMeta, deleteUCharString); + uhash_setValueDeleter(gOlsonToMeta, uprv_deleteUObject); + } +} + + +const UVector* U_EXPORT2 +ZoneMeta::getMetazoneMappings(const UnicodeString &tzid) { + UErrorCode status = U_ZERO_ERROR; + char16_t tzidUChars[ZID_KEY_MAX + 1]; + tzid.extract(tzidUChars, ZID_KEY_MAX + 1, status); + if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING) { + return nullptr; + } + + umtx_initOnce(gOlsonToMetaInitOnce, &olsonToMetaInit, status); + if (U_FAILURE(status)) { + return nullptr; + } + + // get the mapping from cache + const UVector *result = nullptr; + + umtx_lock(&gZoneMetaLock); + { + result = (UVector*) uhash_get(gOlsonToMeta, tzidUChars); + } + umtx_unlock(&gZoneMetaLock); + + if (result != nullptr) { + return result; + } + + // miss the cache - create new one + UVector *tmpResult = createMetazoneMappings(tzid); + if (tmpResult == nullptr) { + // not available + return nullptr; + } + + // put the new one into the cache + umtx_lock(&gZoneMetaLock); + { + // make sure it's already created + result = (UVector*) uhash_get(gOlsonToMeta, tzidUChars); + if (result == nullptr) { + // add the one just created + int32_t tzidLen = tzid.length() + 1; + char16_t *key = (char16_t*)uprv_malloc(tzidLen * sizeof(char16_t)); + if (key == nullptr) { + // memory allocation error.. just return nullptr + result = nullptr; + delete tmpResult; + } else { + tzid.extract(key, tzidLen, status); + uhash_put(gOlsonToMeta, key, tmpResult, &status); + if (U_FAILURE(status)) { + // delete the mapping + result = nullptr; + delete tmpResult; + } else { + result = tmpResult; + } + } + } else { + // another thread already put the one + delete tmpResult; + } + } + umtx_unlock(&gZoneMetaLock); + + return result; +} + +UVector* +ZoneMeta::createMetazoneMappings(const UnicodeString &tzid) { + LocalPointer <UVector> mzMappings; + UErrorCode status = U_ZERO_ERROR; + + UnicodeString canonicalID; + UResourceBundle *rb = ures_openDirect(nullptr, gMetaZones, &status); + ures_getByKey(rb, gMetazoneInfo, rb, &status); + getCanonicalCLDRID(tzid, canonicalID, status); + + if (U_SUCCESS(status)) { + char tzKey[ZID_KEY_MAX + 1]; + int32_t tzKeyLen = canonicalID.extract(0, canonicalID.length(), tzKey, sizeof(tzKey), US_INV); + tzKey[tzKeyLen] = 0; + + // tzid keys are using ':' as separators + char *p = tzKey; + while (*p) { + if (*p == '/') { + *p = ':'; + } + p++; + } + + ures_getByKey(rb, tzKey, rb, &status); + + if (U_SUCCESS(status)) { + UResourceBundle *mz = nullptr; + while (ures_hasNext(rb)) { + mz = ures_getNextResource(rb, mz, &status); + + const char16_t *mz_name = ures_getStringByIndex(mz, 0, nullptr, &status); + const char16_t *mz_from = gDefaultFrom; + const char16_t *mz_to = gDefaultTo; + + if (ures_getSize(mz) == 3) { + mz_from = ures_getStringByIndex(mz, 1, nullptr, &status); + mz_to = ures_getStringByIndex(mz, 2, nullptr, &status); + } + + if(U_FAILURE(status)){ + status = U_ZERO_ERROR; + continue; + } + // We do not want to use SimpleDateformat to parse boundary dates, + // because this code could be triggered by the initialization code + // used by SimpleDateFormat. + UDate from = parseDate(mz_from, status); + UDate to = parseDate(mz_to, status); + if (U_FAILURE(status)) { + status = U_ZERO_ERROR; + continue; + } + + LocalPointer<OlsonToMetaMappingEntry> entry(new OlsonToMetaMappingEntry, status); + if (U_FAILURE(status)) { + break; + } + entry->mzid = mz_name; + entry->from = from; + entry->to = to; + + if (mzMappings.isNull()) { + mzMappings.adoptInsteadAndCheckErrorCode( + new UVector(deleteOlsonToMetaMappingEntry, nullptr, status), status); + if (U_FAILURE(status)) { + break; + } + } + + mzMappings->adoptElement(entry.orphan(), status); + if (U_FAILURE(status)) { + break; + } + } + ures_close(mz); + } + } + ures_close(rb); + return U_SUCCESS(status) ? mzMappings.orphan() : nullptr; +} + +UnicodeString& U_EXPORT2 +ZoneMeta::getZoneIdByMetazone(const UnicodeString &mzid, const UnicodeString ®ion, UnicodeString &result) { + UErrorCode status = U_ZERO_ERROR; + const char16_t *tzid = nullptr; + int32_t tzidLen = 0; + char keyBuf[ZID_KEY_MAX + 1]; + int32_t keyLen = 0; + + if (mzid.isBogus() || mzid.length() > ZID_KEY_MAX) { + result.setToBogus(); + return result; + } + + keyLen = mzid.extract(0, mzid.length(), keyBuf, ZID_KEY_MAX + 1, US_INV); + keyBuf[keyLen] = 0; + + UResourceBundle *rb = ures_openDirect(nullptr, gMetaZones, &status); + ures_getByKey(rb, gMapTimezonesTag, rb, &status); + ures_getByKey(rb, keyBuf, rb, &status); + + if (U_SUCCESS(status)) { + // check region mapping + if (region.length() == 2 || region.length() == 3) { + keyLen = region.extract(0, region.length(), keyBuf, ZID_KEY_MAX + 1, US_INV); + keyBuf[keyLen] = 0; + tzid = ures_getStringByKey(rb, keyBuf, &tzidLen, &status); + if (status == U_MISSING_RESOURCE_ERROR) { + status = U_ZERO_ERROR; + } + } + if (U_SUCCESS(status) && tzid == nullptr) { + // try "001" + tzid = ures_getStringByKey(rb, gWorldTag, &tzidLen, &status); + } + } + ures_close(rb); + + if (tzid == nullptr) { + result.setToBogus(); + } else { + result.setTo(tzid, tzidLen); + } + + return result; +} + +static void U_CALLCONV initAvailableMetaZoneIDs () { + U_ASSERT(gMetaZoneIDs == nullptr); + U_ASSERT(gMetaZoneIDTable == nullptr); + ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup); + + UErrorCode status = U_ZERO_ERROR; + gMetaZoneIDTable = uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, nullptr, &status); + if (U_FAILURE(status) || gMetaZoneIDTable == nullptr) { + gMetaZoneIDTable = nullptr; + return; + } + uhash_setKeyDeleter(gMetaZoneIDTable, uprv_deleteUObject); + // No valueDeleter, because the vector maintain the value objects + gMetaZoneIDs = new UVector(nullptr, uhash_compareUChars, status); + if (U_FAILURE(status) || gMetaZoneIDs == nullptr) { + delete gMetaZoneIDs; + gMetaZoneIDs = nullptr; + uhash_close(gMetaZoneIDTable); + gMetaZoneIDTable = nullptr; + return; + } + gMetaZoneIDs->setDeleter(uprv_free); + + UResourceBundle *rb = ures_openDirect(nullptr, gMetaZones, &status); + UResourceBundle *bundle = ures_getByKey(rb, gMapTimezonesTag, nullptr, &status); + StackUResourceBundle res; + while (U_SUCCESS(status) && ures_hasNext(bundle)) { + ures_getNextResource(bundle, res.getAlias(), &status); + if (U_FAILURE(status)) { + break; + } + const char *mzID = ures_getKey(res.getAlias()); + int32_t len = static_cast<int32_t>(uprv_strlen(mzID)); + LocalMemory<char16_t> uMzID((char16_t*)uprv_malloc(sizeof(char16_t) * (len + 1))); + if (uMzID.isNull()) { + status = U_MEMORY_ALLOCATION_ERROR; + break; + } + u_charsToUChars(mzID, uMzID.getAlias(), len); + uMzID[len] = 0; + LocalPointer<UnicodeString> usMzID(new UnicodeString(uMzID.getAlias()), status); + if (U_FAILURE(status)) { + break; + } + if (uhash_get(gMetaZoneIDTable, usMzID.getAlias()) == nullptr) { + // Note: gMetaZoneIDTable adopts its keys, but not its values. + // gMetaZoneIDs adopts its values. + uhash_put(gMetaZoneIDTable, usMzID.orphan(), uMzID.getAlias(), &status); + gMetaZoneIDs->adoptElement(uMzID.orphan(), status); + } + } + ures_close(bundle); + ures_close(rb); + + if (U_FAILURE(status)) { + uhash_close(gMetaZoneIDTable); + delete gMetaZoneIDs; + gMetaZoneIDTable = nullptr; + gMetaZoneIDs = nullptr; + } +} + +const UVector* +ZoneMeta::getAvailableMetazoneIDs() { + umtx_initOnce(gMetaZoneIDsInitOnce, &initAvailableMetaZoneIDs); + return gMetaZoneIDs; +} + +const char16_t* +ZoneMeta::findMetaZoneID(const UnicodeString& mzid) { + umtx_initOnce(gMetaZoneIDsInitOnce, &initAvailableMetaZoneIDs); + if (gMetaZoneIDTable == nullptr) { + return nullptr; + } + return (const char16_t*)uhash_get(gMetaZoneIDTable, &mzid); +} + +const char16_t* +ZoneMeta::findTimeZoneID(const UnicodeString& tzid) { + return TimeZone::findID(tzid); +} + + +TimeZone* +ZoneMeta::createCustomTimeZone(int32_t offset) { + UBool negative = false; + int32_t tmp = offset; + if (offset < 0) { + negative = true; + tmp = -offset; + } + uint8_t hour, min, sec; + + tmp /= 1000; + sec = static_cast<uint8_t>(tmp % 60); + tmp /= 60; + min = static_cast<uint8_t>(tmp % 60); + hour = static_cast<uint8_t>(tmp / 60); + + UnicodeString zid; + formatCustomID(hour, min, sec, negative, zid); + return new SimpleTimeZone(offset, zid); +} + +UnicodeString& +ZoneMeta::formatCustomID(uint8_t hour, uint8_t min, uint8_t sec, UBool negative, UnicodeString& id) { + // Create normalized time zone ID - GMT[+|-]HH:mm[:ss] + id.setTo(gCustomTzPrefix, -1); + if (hour != 0 || min != 0) { + if (negative) { + id.append((char16_t)0x2D); // '-' + } else { + id.append((char16_t)0x2B); // '+' + } + // Always use US-ASCII digits + id.append((char16_t)(0x30 + (hour%100)/10)); + id.append((char16_t)(0x30 + (hour%10))); + id.append((char16_t)0x3A); // ':' + id.append((char16_t)(0x30 + (min%100)/10)); + id.append((char16_t)(0x30 + (min%10))); + if (sec != 0) { + id.append((char16_t)0x3A); // ':' + id.append((char16_t)(0x30 + (sec%100)/10)); + id.append((char16_t)(0x30 + (sec%10))); + } + } + return id; +} + +const char16_t* +ZoneMeta::getShortID(const TimeZone& tz) { + const char16_t* canonicalID = nullptr; + if (dynamic_cast<const OlsonTimeZone *>(&tz) != nullptr) { + // short cut for OlsonTimeZone + const OlsonTimeZone *otz = (const OlsonTimeZone*)&tz; + canonicalID = otz->getCanonicalID(); + } + if (canonicalID == nullptr) { + return nullptr; + } + return getShortIDFromCanonical(canonicalID); +} + +const char16_t* +ZoneMeta::getShortID(const UnicodeString& id) { + UErrorCode status = U_ZERO_ERROR; + const char16_t* canonicalID = ZoneMeta::getCanonicalCLDRID(id, status); + if (U_FAILURE(status) || canonicalID == nullptr) { + return nullptr; + } + return ZoneMeta::getShortIDFromCanonical(canonicalID); +} + +const char16_t* +ZoneMeta::getShortIDFromCanonical(const char16_t* canonicalID) { + const char16_t* shortID = nullptr; + int32_t len = u_strlen(canonicalID); + char tzidKey[ZID_KEY_MAX + 1]; + + u_UCharsToChars(canonicalID, tzidKey, len); + tzidKey[len] = (char) 0; // Make sure it is null terminated. + + // replace '/' with ':' + char *p = tzidKey; + while (*p++) { + if (*p == '/') { + *p = ':'; + } + } + + UErrorCode status = U_ZERO_ERROR; + UResourceBundle *rb = ures_openDirect(nullptr, gKeyTypeData, &status); + ures_getByKey(rb, gTypeMapTag, rb, &status); + ures_getByKey(rb, gTimezoneTag, rb, &status); + shortID = ures_getStringByKey(rb, tzidKey, nullptr, &status); + ures_close(rb); + + return shortID; +} + +U_NAMESPACE_END + +#endif /* #if !UCONFIG_NO_FORMATTING */ |