| /* |
| ******************************************************************************* |
| * Copyright (C) 2007-2009, 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 "umutex.h" |
| #include "uvector.h" |
| #include "cmemory.h" |
| #include "gregoimp.h" |
| #include "cstring.h" |
| #include "ucln_in.h" |
| |
| // Metazone mapping tables |
| static UMTX gZoneMetaLock = NULL; |
| static UHashtable *gCanonicalMap = NULL; |
| static UHashtable *gOlsonToMeta = NULL; |
| static UHashtable *gMetaToOlson = NULL; |
| static UBool gCanonicalMapInitialized = FALSE; |
| static UBool gOlsonToMetaInitialized = FALSE; |
| static UBool gMetaToOlsonInitialized = FALSE; |
| static UChar **gUStringTable = NULL; |
| static int32_t gUStringCount = 0; |
| static int32_t gUStringAlloc = 0; |
| |
| // Currently (ICU 4.1.3+), gUStringTable only contains strings allocated in the section of |
| // createCanonicalMap that iterates over the enumerator created with TimeZone::createEnumeration. |
| // And currently, that allocates a total of 22 strings. So USTRING_ALLOC_START is defined to |
| // be adequate for that set, and USTRING_ALLOC_INCR is a reasonable expansion increment. In |
| // future versions of ICU, these numbers may need adjusting to avoid excessive reallocs, or to |
| // avoid allocating unused memory (but in any case the effects are small). |
| #define USTRING_ALLOC_START 24 |
| #define USTRING_ALLOC_INCR 12 |
| |
| U_CDECL_BEGIN |
| |
| // We have switched CanonicalMap to use const UChar* strings for the key and for the id field of |
| // CanonicalMapEntry; that is because for the most part these now point into UChar strings in the |
| // shared data file, in order to reduce process-specific dynamically-allocated memory. Consequently, |
| // there is no longer a deleter for the key field, and the deleter for CanonicalMapEntry |
| // no longer frees the id field. However, for the few strings that are obtained from the |
| // TimeZone::createEnumeration() enumerator or from TimeZone::dereferOlsonLink instead of the |
| // data file, we do need to allocate copies. In order to ensure that these strings are freed by |
| // zoneMeta_cleanup(), we need to create a little memory manager for them; this is in the form of |
| // a table that tracks the strings allocated for this purpose. The following three functions |
| // (along with the gUStringXxxxx statics) are used to allocate and free such strings. |
| |
| // The following allocs space for a UChar* string of the specified length, puts a pointer to the string |
| // in gUStringTable, and returns either a pointer to the allocated string space, or NULL for failure. |
| static UChar * allocUStringInTable(int32_t uStringLen) { |
| UChar * uStringSpace = NULL; |
| // initialize the table if necessary |
| umtx_lock(&gZoneMetaLock); |
| if (gUStringTable == NULL) { |
| gUStringTable = (UChar**)uprv_malloc(USTRING_ALLOC_START*sizeof(UChar*)); |
| if (gUStringTable != NULL) { |
| gUStringAlloc = USTRING_ALLOC_START; |
| } |
| } |
| if (gUStringTable != NULL) { |
| // expand the table if necessary |
| if (gUStringCount == gUStringAlloc) { |
| UChar ** newTable = (UChar**)uprv_realloc(gUStringTable, (gUStringAlloc+USTRING_ALLOC_INCR)*sizeof(UChar*)); |
| if (newTable != NULL) { |
| gUStringTable = newTable; |
| gUStringAlloc += USTRING_ALLOC_INCR; |
| } |
| } |
| // add the string if possible |
| if (gUStringCount < gUStringAlloc) { |
| uStringSpace = (UChar*)uprv_malloc(uStringLen*sizeof(UChar)); |
| if (uStringSpace != NULL) { |
| gUStringTable[gUStringCount++] = uStringSpace; |
| } |
| } |
| } |
| umtx_unlock(&gZoneMetaLock); |
| return uStringSpace; |
| } |
| |
| static void removeLastUStringFromTable(void) { |
| umtx_lock(&gZoneMetaLock); |
| if (gUStringCount > 0) { |
| free(gUStringTable[--gUStringCount]); |
| } |
| umtx_unlock(&gZoneMetaLock); |
| } |
| |
| static void freeUStringTable(void) { |
| int32_t uStringCount = gUStringCount; |
| gUStringCount = 0; |
| gUStringAlloc = 0; |
| if (gUStringTable != NULL) { |
| while (uStringCount > 0) { |
| free(gUStringTable[--uStringCount]); |
| } |
| free(gUStringTable); |
| gUStringTable = NULL; |
| } |
| } |
| |
| /** |
| * Cleanup callback func |
| */ |
| static UBool U_CALLCONV zoneMeta_cleanup(void) |
| { |
| umtx_destroy(&gZoneMetaLock); |
| |
| if (gCanonicalMap != NULL) { |
| uhash_close(gCanonicalMap); |
| gCanonicalMap = NULL; |
| } |
| gCanonicalMapInitialized = FALSE; |
| |
| if (gOlsonToMeta != NULL) { |
| uhash_close(gOlsonToMeta); |
| gOlsonToMeta = NULL; |
| } |
| gOlsonToMetaInitialized = FALSE; |
| |
| if (gMetaToOlson != NULL) { |
| uhash_close(gMetaToOlson); |
| gMetaToOlson = NULL; |
| } |
| gMetaToOlsonInitialized = FALSE; |
| |
| freeUStringTable(); |
| |
| return TRUE; |
| } |
| |
| /** |
| * Deleter for UChar* string |
| */ |
| static void U_CALLCONV |
| deleteUCharString(void *obj) { |
| UChar *entry = (UChar*)obj; |
| uprv_free(entry); |
| } |
| |
| /** |
| * Deleter for UVector |
| */ |
| static void U_CALLCONV |
| deleteUVector(void *obj) { |
| delete (U_NAMESPACE_QUALIFIER UVector*) obj; |
| } |
| |
| /** |
| * Deleter for CanonicalMapEntry |
| */ |
| static void U_CALLCONV |
| deleteCanonicalMapEntry(void *obj) { |
| U_NAMESPACE_QUALIFIER CanonicalMapEntry *entry = (U_NAMESPACE_QUALIFIER CanonicalMapEntry*)obj; |
| uprv_free(entry); |
| } |
| |
| /** |
| * Deleter for OlsonToMetaMappingEntry |
| */ |
| static void U_CALLCONV |
| deleteOlsonToMetaMappingEntry(void *obj) { |
| U_NAMESPACE_QUALIFIER OlsonToMetaMappingEntry *entry = (U_NAMESPACE_QUALIFIER OlsonToMetaMappingEntry*)obj; |
| uprv_free(entry); |
| } |
| |
| /** |
| * Deleter for MetaToOlsonMappingEntry |
| */ |
| static void U_CALLCONV |
| deleteMetaToOlsonMappingEntry(void *obj) { |
| U_NAMESPACE_QUALIFIER MetaToOlsonMappingEntry *entry = (U_NAMESPACE_QUALIFIER MetaToOlsonMappingEntry*)obj; |
| uprv_free(entry->territory); |
| uprv_free(entry); |
| } |
| U_CDECL_END |
| |
| U_NAMESPACE_BEGIN |
| |
| #define ZID_KEY_MAX 128 |
| static const char gZoneStringsTag[] = "zoneStrings"; |
| static const char gUseMetazoneTag[] = "um"; |
| |
| static const char gSupplementalData[] = "supplementalData"; |
| static const char gMapTimezonesTag[] = "mapTimezones"; |
| static const char gMetazonesTag[] = "metazones"; |
| static const char gZoneFormattingTag[] = "zoneFormatting"; |
| static const char gCanonicalTag[] = "canonical"; |
| static const char gTerritoryTag[] = "territory"; |
| static const char gAliasesTag[] = "aliases"; |
| static const char gMultizoneTag[] = "multizone"; |
| |
| static const char gMetazoneInfo[] = "metazoneInfo"; |
| static const char gMetazoneMappings[] = "metazoneMappings"; |
| |
| #define MZID_PREFIX_LEN 5 |
| static const char gMetazoneIdPrefix[] = "meta:"; |
| |
| static const UChar gWorld[] = {0x30, 0x30, 0x31, 0x00}; // "001" |
| |
| #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 UChar *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; |
| } |
| |
| UHashtable* |
| ZoneMeta::createCanonicalMap(void) { |
| UErrorCode status = U_ZERO_ERROR; |
| |
| UHashtable *canonicalMap = NULL; |
| UResourceBundle *zoneFormatting = NULL; |
| UResourceBundle *tzitem = NULL; |
| UResourceBundle *aliases = NULL; |
| |
| StringEnumeration* tzenum = NULL; |
| int32_t numZones; |
| |
| canonicalMap = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status); |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| // no key deleter |
| uhash_setValueDeleter(canonicalMap, deleteCanonicalMapEntry); |
| |
| zoneFormatting = ures_openDirect(NULL, gSupplementalData, &status); |
| zoneFormatting = ures_getByKey(zoneFormatting, gZoneFormattingTag, zoneFormatting, &status); |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| |
| while (ures_hasNext(zoneFormatting)) { |
| tzitem = ures_getNextResource(zoneFormatting, tzitem, &status); |
| if (U_FAILURE(status)) { |
| status = U_ZERO_ERROR; |
| continue; |
| } |
| if (ures_getType(tzitem) != URES_TABLE) { |
| continue; |
| } |
| |
| int32_t canonicalLen; |
| const UChar *canonical = ures_getStringByKey(tzitem, gCanonicalTag, &canonicalLen, &status); |
| if (U_FAILURE(status)) { |
| status = U_ZERO_ERROR; |
| continue; |
| } |
| |
| int32_t territoryLen; |
| const UChar *territory = ures_getStringByKey(tzitem, gTerritoryTag, &territoryLen, &status); |
| if (U_FAILURE(status)) { |
| territory = NULL; |
| status = U_ZERO_ERROR; |
| } |
| |
| // Create canonical map entry |
| CanonicalMapEntry *entry = (CanonicalMapEntry*)uprv_malloc(sizeof(CanonicalMapEntry)); |
| if (entry == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| goto error_cleanup; |
| } |
| entry->id = canonical; |
| if (territory == NULL || u_strcmp(territory, gWorld) == 0) { |
| entry->country = NULL; |
| } else { |
| entry->country = territory; |
| } |
| |
| // Put this entry in the hashtable. Since this hashtable has no key deleter, |
| // key is treated as const, but must be passed as non-const. |
| uhash_put(canonicalMap, (UChar*)canonical, entry, &status); |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| |
| // Get aliases |
| aliases = ures_getByKey(tzitem, gAliasesTag, aliases, &status); |
| if (U_FAILURE(status)) { |
| // No aliases |
| status = U_ZERO_ERROR; |
| continue; |
| } |
| |
| while (ures_hasNext(aliases)) { |
| const UChar* alias = ures_getNextString(aliases, NULL, NULL, &status); |
| if (U_FAILURE(status)) { |
| status = U_ZERO_ERROR; |
| continue; |
| } |
| // Create canonical map entry for this alias |
| entry = (CanonicalMapEntry*)uprv_malloc(sizeof(CanonicalMapEntry)); |
| if (entry == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| goto error_cleanup; |
| } |
| entry->id = canonical; |
| if (territory == NULL || u_strcmp(territory, gWorld) == 0) { |
| entry->country = NULL; |
| } else { |
| entry->country = territory; |
| } |
| |
| // Put this entry in the hashtable. Since this hashtable has no key deleter, |
| // key is treated as const, but must be passed as non-const. |
| uhash_put(canonicalMap, (UChar*)alias, entry, &status); |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| } |
| } |
| |
| // Some available Olson zones are not included in CLDR data (such as Asia/Riyadh87). |
| // Also, when we update Olson tzdata, new zones may be added. |
| // This code scans all available zones in zoneinfo.res, and if any of them are |
| // missing, add them to the map. |
| tzenum = TimeZone::createEnumeration(); |
| numZones = tzenum->count(status); |
| if (U_SUCCESS(status)) { |
| int32_t i; |
| for (i = 0; i < numZones; i++) { |
| const UnicodeString *zone = tzenum->snext(status); |
| if (U_FAILURE(status)) { |
| // We should not get here. |
| status = U_ZERO_ERROR; |
| continue; |
| } |
| UChar zoneUChars[ZID_KEY_MAX]; |
| int32_t zoneUCharsLen = zone->extract(zoneUChars, ZID_KEY_MAX, status) + 1; // Add one for NUL termination |
| if (U_FAILURE(status) || status==U_STRING_NOT_TERMINATED_WARNING) { |
| status = U_ZERO_ERROR; |
| continue; // zone id is too long to extract |
| } |
| CanonicalMapEntry *entry = (CanonicalMapEntry*)uhash_get(canonicalMap, zoneUChars); |
| if (entry) { |
| // Already included in CLDR data |
| continue; |
| } |
| // Not in CLDR data, but it could be new one whose alias is available |
| // in CLDR. |
| int32_t nTzdataEquivalent = TimeZone::countEquivalentIDs(*zone); |
| int32_t j; |
| for (j = 0; j < nTzdataEquivalent; j++) { |
| UnicodeString alias = TimeZone::getEquivalentID(*zone, j); |
| if (alias == *zone) { |
| continue; |
| } |
| UChar aliasUChars[ZID_KEY_MAX]; |
| alias.extract(aliasUChars, ZID_KEY_MAX, status); |
| if (U_FAILURE(status) || status==U_STRING_NOT_TERMINATED_WARNING) { |
| status = U_ZERO_ERROR; |
| continue; // zone id is too long to extract |
| } |
| entry = (CanonicalMapEntry*)uhash_get(canonicalMap, aliasUChars); |
| if (entry != NULL) { |
| break; |
| } |
| } |
| // Create a new map entry |
| CanonicalMapEntry* newEntry = (CanonicalMapEntry*)uprv_malloc(sizeof(CanonicalMapEntry)); |
| int32_t idLen; |
| if (newEntry == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| goto error_cleanup; |
| } |
| if (entry == NULL) { |
| // Set dereferenced zone ID as the canonical ID |
| UnicodeString derefZone; |
| TimeZone::dereferOlsonLink(*zone, derefZone); |
| if (derefZone.length() == 0) { |
| // It should never happen.. but just in case |
| derefZone = *zone; |
| } |
| idLen = derefZone.length() + 1; |
| newEntry->id = allocUStringInTable(idLen); |
| if (newEntry->id == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| uprv_free(newEntry); |
| goto error_cleanup; |
| } |
| // Copy NULL terminated string |
| derefZone.extract((UChar*)(newEntry->id), idLen, status); |
| if (U_FAILURE(status)) { |
| removeLastUStringFromTable(); |
| uprv_free(newEntry); |
| goto error_cleanup; |
| } |
| // No territory information available |
| newEntry->country = NULL; |
| } else { |
| // Duplicate the entry |
| newEntry->id = entry->id; |
| newEntry->country = entry->country; |
| } |
| |
| // Put this entry in the hashtable |
| UChar *key = allocUStringInTable(zoneUCharsLen); |
| if (key == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| deleteCanonicalMapEntry(newEntry); |
| goto error_cleanup; |
| } |
| u_strncpy(key, zoneUChars, zoneUCharsLen); |
| uhash_put(canonicalMap, key, newEntry, &status); |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| } |
| } |
| |
| normal_cleanup: |
| ures_close(aliases); |
| ures_close(tzitem); |
| ures_close(zoneFormatting); |
| delete tzenum; |
| return canonicalMap; |
| |
| error_cleanup: |
| if (canonicalMap != NULL) { |
| uhash_close(canonicalMap); |
| canonicalMap = NULL; |
| } |
| goto normal_cleanup; |
| } |
| |
| /* |
| * Creating Olson tzid to metazone mappings from resource (3.8.1 and beyond) |
| */ |
| UHashtable* |
| ZoneMeta::createOlsonToMetaMap(void) { |
| UErrorCode status = U_ZERO_ERROR; |
| |
| UHashtable *olsonToMeta = NULL; |
| UResourceBundle *metazoneMappings = NULL; |
| UResourceBundle *zoneItem = NULL; |
| UResourceBundle *mz = NULL; |
| StringEnumeration *tzids = NULL; |
| |
| olsonToMeta = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status); |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| uhash_setKeyDeleter(olsonToMeta, deleteUCharString); |
| uhash_setValueDeleter(olsonToMeta, deleteUVector); |
| |
| // Read metazone mappings from metazoneInfo bundle |
| metazoneMappings = ures_openDirect(NULL, gMetazoneInfo, &status); |
| metazoneMappings = ures_getByKey(metazoneMappings, gMetazoneMappings, metazoneMappings, &status); |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| |
| // Walk through all canonical tzids |
| char zidkey[ZID_KEY_MAX]; |
| |
| tzids = TimeZone::createEnumeration(); |
| const UnicodeString *tzid; |
| while ((tzid = tzids->snext(status))) { |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| // We may skip aliases, because the bundle |
| // contains only canonical IDs. For now, try |
| // all of them. |
| tzid->extract(0, tzid->length(), zidkey, sizeof(zidkey), US_INV); |
| zidkey[sizeof(zidkey)-1] = 0; // NULL terminate just in case. |
| |
| // Replace '/' with ':' |
| UBool foundSep = FALSE; |
| char *p = zidkey; |
| while (*p) { |
| if (*p == '/') { |
| *p = ':'; |
| foundSep = TRUE; |
| } |
| p++; |
| } |
| if (!foundSep) { |
| // A valid time zone key has at least one separator |
| continue; |
| } |
| |
| zoneItem = ures_getByKey(metazoneMappings, zidkey, zoneItem, &status); |
| if (U_FAILURE(status)) { |
| status = U_ZERO_ERROR; |
| continue; |
| } |
| |
| UVector *mzMappings = NULL; |
| while (ures_hasNext(zoneItem)) { |
| mz = ures_getNextResource(zoneItem, mz, &status); |
| const UChar *mz_name = ures_getStringByIndex(mz, 0, NULL, &status); |
| const UChar *mz_from = ures_getStringByIndex(mz, 1, NULL, &status); |
| const UChar *mz_to = ures_getStringByIndex(mz, 2, NULL, &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; |
| } |
| |
| OlsonToMetaMappingEntry *entry = (OlsonToMetaMappingEntry*)uprv_malloc(sizeof(OlsonToMetaMappingEntry)); |
| if (entry == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| break; |
| } |
| entry->mzid = mz_name; |
| entry->from = from; |
| entry->to = to; |
| |
| if (mzMappings == NULL) { |
| mzMappings = new UVector(deleteOlsonToMetaMappingEntry, NULL, status); |
| if (U_FAILURE(status)) { |
| delete mzMappings; |
| deleteOlsonToMetaMappingEntry(entry); |
| uprv_free(entry); |
| break; |
| } |
| } |
| |
| mzMappings->addElement(entry, status); |
| if (U_FAILURE(status)) { |
| break; |
| } |
| } |
| |
| if (U_FAILURE(status)) { |
| if (mzMappings != NULL) { |
| delete mzMappings; |
| } |
| goto error_cleanup; |
| } |
| if (mzMappings != NULL) { |
| // Add to hashtable |
| int32_t tzidLen = tzid->length() + 1; // Add one for NUL terminator |
| UChar *key = (UChar*)uprv_malloc(tzidLen * sizeof(UChar)); |
| if (key == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| delete mzMappings; |
| goto error_cleanup; |
| } |
| tzid->extract(key, tzidLen, status); |
| uhash_put(olsonToMeta, key, mzMappings, &status); |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| } |
| } |
| |
| normal_cleanup: |
| if (tzids != NULL) { |
| delete tzids; |
| } |
| ures_close(zoneItem); |
| ures_close(mz); |
| ures_close(metazoneMappings); |
| return olsonToMeta; |
| |
| error_cleanup: |
| if (olsonToMeta != NULL) { |
| uhash_close(olsonToMeta); |
| olsonToMeta = NULL; |
| } |
| goto normal_cleanup; |
| } |
| |
| UHashtable* |
| ZoneMeta::createMetaToOlsonMap(void) { |
| UErrorCode status = U_ZERO_ERROR; |
| |
| UHashtable *metaToOlson = NULL; |
| UResourceBundle *metazones = NULL; |
| UResourceBundle *mz = NULL; |
| |
| metaToOlson = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status); |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| uhash_setKeyDeleter(metaToOlson, deleteUCharString); |
| uhash_setValueDeleter(metaToOlson, deleteUVector); |
| |
| metazones = ures_openDirect(NULL, gSupplementalData, &status); |
| metazones = ures_getByKey(metazones, gMapTimezonesTag, metazones, &status); |
| metazones = ures_getByKey(metazones, gMetazonesTag, metazones, &status); |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| |
| while (ures_hasNext(metazones)) { |
| mz = ures_getNextResource(metazones, mz, &status); |
| if (U_FAILURE(status)) { |
| status = U_ZERO_ERROR; |
| continue; |
| } |
| const char *mzkey = ures_getKey(mz); |
| if (uprv_strncmp(mzkey, gMetazoneIdPrefix, MZID_PREFIX_LEN) == 0) { |
| const char *mzid = mzkey + MZID_PREFIX_LEN; |
| const char *territory = uprv_strrchr(mzid, '_'); |
| int32_t mzidLen = 0; |
| int32_t territoryLen = 0; |
| if (territory) { |
| mzidLen = territory - mzid; |
| territory++; |
| territoryLen = uprv_strlen(territory); |
| } |
| if (mzidLen > 0 && territoryLen > 0) { |
| int32_t tzidLen; |
| const UChar *tzid = ures_getStringByIndex(mz, 0, &tzidLen, &status); |
| if (U_SUCCESS(status)) { |
| // Create MetaToOlsonMappingEntry |
| MetaToOlsonMappingEntry *entry = (MetaToOlsonMappingEntry*)uprv_malloc(sizeof(MetaToOlsonMappingEntry)); |
| if (entry == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| goto error_cleanup; |
| } |
| entry->id = tzid; |
| entry->territory = (UChar*)uprv_malloc((territoryLen + 1) * sizeof(UChar)); |
| if (entry->territory == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| uprv_free(entry); |
| goto error_cleanup; |
| } |
| u_charsToUChars(territory, entry->territory, territoryLen + 1); |
| |
| // Check if mapping entries for metazone is already available |
| if (mzidLen < ZID_KEY_MAX) { |
| UChar mzidUChars[ZID_KEY_MAX]; |
| u_charsToUChars(mzid, mzidUChars, mzidLen); |
| mzidUChars[mzidLen++] = 0; // Add NUL terminator |
| UVector *tzMappings = (UVector*)uhash_get(metaToOlson, mzidUChars); |
| if (tzMappings == NULL) { |
| // Create new UVector and put it into the hashtable |
| tzMappings = new UVector(deleteMetaToOlsonMappingEntry, NULL, status); |
| if (U_FAILURE(status)) { |
| deleteMetaToOlsonMappingEntry(entry); |
| goto error_cleanup; |
| } |
| UChar *key = (UChar*)uprv_malloc(mzidLen * sizeof(UChar)); |
| if (key == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| delete tzMappings; |
| deleteMetaToOlsonMappingEntry(entry); |
| goto error_cleanup; |
| } |
| u_strncpy(key, mzidUChars, mzidLen); |
| uhash_put(metaToOlson, key, tzMappings, &status); |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| } |
| tzMappings->addElement(entry, status); |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| } else { |
| deleteMetaToOlsonMappingEntry(entry); |
| } |
| } else { |
| status = U_ZERO_ERROR; |
| } |
| } |
| } |
| } |
| |
| normal_cleanup: |
| ures_close(mz); |
| ures_close(metazones); |
| return metaToOlson; |
| |
| error_cleanup: |
| if (metaToOlson != NULL) { |
| uhash_close(metaToOlson); |
| metaToOlson = NULL; |
| } |
| goto normal_cleanup; |
| } |
| |
| /* |
| * Initialize global objects |
| */ |
| void |
| ZoneMeta::initializeCanonicalMap(void) { |
| UBool initialized; |
| UMTX_CHECK(&gZoneMetaLock, gCanonicalMapInitialized, initialized); |
| if (initialized) { |
| return; |
| } |
| // Initialize hash table |
| UHashtable *tmpCanonicalMap = createCanonicalMap(); |
| |
| umtx_lock(&gZoneMetaLock); |
| if (!gCanonicalMapInitialized) { |
| gCanonicalMap = tmpCanonicalMap; |
| tmpCanonicalMap = NULL; |
| gCanonicalMapInitialized = TRUE; |
| } |
| umtx_unlock(&gZoneMetaLock); |
| |
| // OK to call the following multiple times with the same function |
| ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup); |
| if (tmpCanonicalMap != NULL) { |
| uhash_close(tmpCanonicalMap); |
| } |
| } |
| |
| void |
| ZoneMeta::initializeOlsonToMeta(void) { |
| UBool initialized; |
| UMTX_CHECK(&gZoneMetaLock, gOlsonToMetaInitialized, initialized); |
| if (initialized) { |
| return; |
| } |
| // Initialize hash tables |
| UHashtable *tmpOlsonToMeta = createOlsonToMetaMap(); |
| |
| umtx_lock(&gZoneMetaLock); |
| if (!gOlsonToMetaInitialized) { |
| gOlsonToMeta = tmpOlsonToMeta; |
| tmpOlsonToMeta = NULL; |
| gOlsonToMetaInitialized = TRUE; |
| } |
| umtx_unlock(&gZoneMetaLock); |
| |
| // OK to call the following multiple times with the same function |
| ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup); |
| if (tmpOlsonToMeta != NULL) { |
| uhash_close(tmpOlsonToMeta); |
| } |
| } |
| |
| void |
| ZoneMeta::initializeMetaToOlson(void) { |
| UBool initialized; |
| UMTX_CHECK(&gZoneMetaLock, gMetaToOlsonInitialized, initialized); |
| if (initialized) { |
| return; |
| } |
| // Initialize hash table |
| UHashtable *tmpMetaToOlson = createMetaToOlsonMap(); |
| |
| umtx_lock(&gZoneMetaLock); |
| if (!gMetaToOlsonInitialized) { |
| gMetaToOlson = tmpMetaToOlson; |
| tmpMetaToOlson = NULL; |
| gMetaToOlsonInitialized = TRUE; |
| } |
| umtx_unlock(&gZoneMetaLock); |
| |
| // OK to call the following multiple times with the same function |
| ucln_i18n_registerCleanup(UCLN_I18N_ZONEMETA, zoneMeta_cleanup); |
| if (tmpMetaToOlson != NULL) { |
| uhash_close(tmpMetaToOlson); |
| } |
| } |
| |
| UnicodeString& U_EXPORT2 |
| ZoneMeta::getCanonicalSystemID(const UnicodeString &tzid, UnicodeString &systemID, UErrorCode& status) { |
| const CanonicalMapEntry *entry = getCanonicalInfo(tzid); |
| if (entry != NULL) { |
| systemID.setTo(entry->id); |
| } else { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| } |
| return systemID; |
| } |
| |
| UnicodeString& U_EXPORT2 |
| ZoneMeta::getCanonicalCountry(const UnicodeString &tzid, UnicodeString &canonicalCountry) { |
| const CanonicalMapEntry *entry = getCanonicalInfo(tzid); |
| if (entry != NULL && entry->country != NULL) { |
| canonicalCountry.setTo(entry->country); |
| } else { |
| // Use the input tzid |
| canonicalCountry.remove(); |
| } |
| return canonicalCountry; |
| } |
| |
| const CanonicalMapEntry* U_EXPORT2 |
| ZoneMeta::getCanonicalInfo(const UnicodeString &tzid) { |
| initializeCanonicalMap(); |
| CanonicalMapEntry *entry = NULL; |
| if (gCanonicalMap != NULL) { |
| UErrorCode status = U_ZERO_ERROR; |
| UChar tzidUChars[ZID_KEY_MAX]; |
| tzid.extract(tzidUChars, ZID_KEY_MAX, status); |
| if (U_SUCCESS(status) && status!=U_STRING_NOT_TERMINATED_WARNING) { |
| entry = (CanonicalMapEntry*)uhash_get(gCanonicalMap, tzidUChars); |
| } |
| } |
| return entry; |
| } |
| |
| UnicodeString& U_EXPORT2 |
| ZoneMeta::getSingleCountry(const UnicodeString &tzid, UnicodeString &country) { |
| UErrorCode status = U_ZERO_ERROR; |
| |
| // Get canonical country for the zone |
| getCanonicalCountry(tzid, country); |
| |
| if (!country.isEmpty()) { |
| UResourceBundle *supplementalDataBundle = ures_openDirect(NULL, gSupplementalData, &status); |
| UResourceBundle *zoneFormatting = ures_getByKey(supplementalDataBundle, gZoneFormattingTag, NULL, &status); |
| UResourceBundle *multizone = ures_getByKey(zoneFormatting, gMultizoneTag, NULL, &status); |
| |
| if (U_SUCCESS(status)) { |
| while (ures_hasNext(multizone)) { |
| int32_t len; |
| const UChar* multizoneCountry = ures_getNextString(multizone, &len, NULL, &status); |
| if (country.compare(multizoneCountry, len) == 0) { |
| // Included in the multizone country list |
| country.remove(); |
| break; |
| } |
| } |
| } |
| |
| ures_close(multizone); |
| ures_close(zoneFormatting); |
| ures_close(supplementalDataBundle); |
| } |
| |
| return country; |
| } |
| |
| UnicodeString& U_EXPORT2 |
| ZoneMeta::getMetazoneID(const UnicodeString &tzid, UDate date, UnicodeString &result) { |
| UBool isSet = FALSE; |
| const UVector *mappings = getMetazoneMappings(tzid); |
| if (mappings != NULL) { |
| 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.remove(); |
| } |
| return result; |
| } |
| |
| const UVector* U_EXPORT2 |
| ZoneMeta::getMetazoneMappings(const UnicodeString &tzid) { |
| initializeOlsonToMeta(); |
| const UVector *result = NULL; |
| if (gOlsonToMeta != NULL) { |
| UErrorCode status = U_ZERO_ERROR; |
| UChar tzidUChars[ZID_KEY_MAX]; |
| tzid.extract(tzidUChars, ZID_KEY_MAX, status); |
| if (U_SUCCESS(status) && status!=U_STRING_NOT_TERMINATED_WARNING) { |
| result = (UVector*)uhash_get(gOlsonToMeta, tzidUChars); |
| } |
| } |
| return result; |
| } |
| |
| UnicodeString& U_EXPORT2 |
| ZoneMeta::getZoneIdByMetazone(const UnicodeString &mzid, const UnicodeString ®ion, UnicodeString &result) { |
| initializeMetaToOlson(); |
| UBool isSet = FALSE; |
| if (gMetaToOlson != NULL) { |
| UErrorCode status = U_ZERO_ERROR; |
| UChar mzidUChars[ZID_KEY_MAX]; |
| mzid.extract(mzidUChars, ZID_KEY_MAX, status); |
| if (U_SUCCESS(status) && status!=U_STRING_NOT_TERMINATED_WARNING) { |
| UVector *mappings = (UVector*)uhash_get(gMetaToOlson, mzidUChars); |
| if (mappings != NULL) { |
| // Find a preferred time zone for the given region. |
| for (int32_t i = 0; i < mappings->size(); i++) { |
| MetaToOlsonMappingEntry *olsonmap = (MetaToOlsonMappingEntry*)mappings->elementAt(i); |
| if (region.compare(olsonmap->territory, -1) == 0) { |
| result.setTo(olsonmap->id); |
| isSet = TRUE; |
| break; |
| } else if (u_strcmp(olsonmap->territory, gWorld) == 0) { |
| result.setTo(olsonmap->id); |
| isSet = TRUE; |
| } |
| } |
| } |
| } |
| } |
| if (!isSet) { |
| result.remove(); |
| } |
| return result; |
| } |
| |
| |
| U_NAMESPACE_END |
| |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |
