| /* |
| ******************************************************************************* |
| * Copyright (C) 2007-2010, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ******************************************************************************* |
| */ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| #include "zstrfmt.h" |
| |
| #include "unicode/ustring.h" |
| #include "unicode/putil.h" |
| #include "unicode/msgfmt.h" |
| #include "unicode/basictz.h" |
| #include "unicode/simpletz.h" |
| #include "unicode/rbtz.h" |
| #include "unicode/vtzone.h" |
| |
| #include "uvector.h" |
| #include "cstring.h" |
| #include "cmemory.h" |
| #include "uresimp.h" |
| #include "zonemeta.h" |
| #include "olsontz.h" |
| #include "umutex.h" |
| #include "ucln_in.h" |
| #include "uassert.h" |
| #include "ureslocs.h" |
| |
| /** |
| * global ZoneStringFormatCache stuffs |
| */ |
| static UMTX gZSFCacheLock = NULL; |
| static U_NAMESPACE_QUALIFIER ZSFCache *gZoneStringFormatCache = NULL; |
| |
| U_CDECL_BEGIN |
| /** |
| * ZoneStringFormatCache cleanup callback func |
| */ |
| static UBool U_CALLCONV zoneStringFormat_cleanup(void) |
| { |
| umtx_destroy(&gZSFCacheLock); |
| if (gZoneStringFormatCache != NULL) { |
| delete gZoneStringFormatCache; |
| gZoneStringFormatCache = NULL; |
| } |
| gZoneStringFormatCache = NULL; |
| return TRUE; |
| } |
| |
| /** |
| * Deleter for ZoneStringInfo |
| */ |
| static void U_CALLCONV |
| deleteZoneStringInfo(void *obj) { |
| delete (U_NAMESPACE_QUALIFIER ZoneStringInfo*)obj; |
| } |
| |
| /** |
| * Deleter for ZoneStrings |
| */ |
| static void U_CALLCONV |
| deleteZoneStrings(void *obj) { |
| delete (U_NAMESPACE_QUALIFIER ZoneStrings*)obj; |
| } |
| U_CDECL_END |
| |
| U_NAMESPACE_BEGIN |
| |
| #define ZID_KEY_MAX 128 |
| |
| static const char gCountriesTag[] = "Countries"; |
| static const char gZoneStringsTag[] = "zoneStrings"; |
| static const char gShortGenericTag[] = "sg"; |
| static const char gShortStandardTag[] = "ss"; |
| static const char gShortDaylightTag[] = "sd"; |
| static const char gLongGenericTag[] = "lg"; |
| static const char gLongStandardTag[] = "ls"; |
| static const char gLongDaylightTag[] = "ld"; |
| static const char gExemplarCityTag[] = "ec"; |
| static const char gCommonlyUsedTag[] = "cu"; |
| static const char gFallbackFormatTag[] = "fallbackFormat"; |
| static const char gRegionFormatTag[] = "regionFormat"; |
| |
| #define MZID_PREFIX_LEN 5 |
| static const char gMetazoneIdPrefix[] = "meta:"; |
| |
| #define MAX_METAZONES_PER_ZONE 10 |
| |
| static const UChar gDefFallbackPattern[] = {0x7B, 0x31, 0x7D, 0x20, 0x28, 0x7B, 0x30, 0x7D, 0x29, 0x00}; // "{1} ({0})" |
| static const UChar gDefRegionPattern[] = {0x7B, 0x30, 0x7D, 0x00}; // "{0}" |
| static const UChar gCommonlyUsedTrue[] = {0x31, 0x00}; // "1" |
| |
| static const double kDstCheckRange = (double)184*U_MILLIS_PER_DAY; |
| |
| static int32_t |
| getTimeZoneTranslationTypeIndex(TimeZoneTranslationType type) { |
| int32_t typeIdx = 0; |
| switch (type) { |
| case LOCATION: |
| typeIdx = ZSIDX_LOCATION; |
| break; |
| case GENERIC_LONG: |
| typeIdx = ZSIDX_LONG_GENERIC; |
| break; |
| case GENERIC_SHORT: |
| typeIdx = ZSIDX_SHORT_GENERIC; |
| break; |
| case STANDARD_LONG: |
| typeIdx = ZSIDX_LONG_STANDARD; |
| break; |
| case STANDARD_SHORT: |
| typeIdx = ZSIDX_SHORT_STANDARD; |
| break; |
| case DAYLIGHT_LONG: |
| typeIdx = ZSIDX_LONG_DAYLIGHT; |
| break; |
| case DAYLIGHT_SHORT: |
| typeIdx = ZSIDX_SHORT_DAYLIGHT; |
| break; |
| } |
| return typeIdx; |
| } |
| |
| static int32_t |
| getTimeZoneTranslationType(TimeZoneTranslationTypeIndex typeIdx) { |
| int32_t type = 0; |
| switch (typeIdx) { |
| case ZSIDX_LOCATION: |
| type = LOCATION; |
| break; |
| case ZSIDX_LONG_GENERIC: |
| type = GENERIC_LONG; |
| break; |
| case ZSIDX_SHORT_GENERIC: |
| type = GENERIC_SHORT; |
| break; |
| case ZSIDX_LONG_STANDARD: |
| type = STANDARD_LONG; |
| break; |
| case ZSIDX_SHORT_STANDARD: |
| type = STANDARD_SHORT; |
| break; |
| case ZSIDX_LONG_DAYLIGHT: |
| type = DAYLIGHT_LONG; |
| break; |
| case ZSIDX_COUNT: |
| case ZSIDX_SHORT_DAYLIGHT: |
| type = DAYLIGHT_SHORT; |
| break; |
| default: |
| break; |
| } |
| return type; |
| } |
| |
| #define DEFAULT_CHARACTERNODE_CAPACITY 1 |
| |
| // ---------------------------------------------------------------------------- |
| void CharacterNode::clear() { |
| uprv_memset(this, 0, sizeof(*this)); |
| } |
| |
| void CharacterNode::deleteValues() { |
| if (fValues == NULL) { |
| // Do nothing. |
| } else if (!fHasValuesVector) { |
| deleteZoneStringInfo(fValues); |
| } else { |
| delete (UVector *)fValues; |
| } |
| } |
| |
| void |
| CharacterNode::addValue(void *value, UErrorCode &status) { |
| if (U_FAILURE(status)) { |
| deleteZoneStringInfo(value); |
| return; |
| } |
| if (fValues == NULL) { |
| fValues = value; |
| } else { |
| // At least one value already. |
| if (!fHasValuesVector) { |
| // There is only one value so far, and not in a vector yet. |
| // Create a vector and add the old value. |
| UVector *values = new UVector(deleteZoneStringInfo, NULL, DEFAULT_CHARACTERNODE_CAPACITY, status); |
| if (U_FAILURE(status)) { |
| deleteZoneStringInfo(value); |
| return; |
| } |
| values->addElement(fValues, status); |
| fValues = values; |
| fHasValuesVector = TRUE; |
| } |
| // Add the new value. |
| ((UVector *)fValues)->addElement(value, status); |
| } |
| } |
| |
| //---------------------------------------------------------------------------- |
| // Virtual destructor to avoid warning |
| TextTrieMapSearchResultHandler::~TextTrieMapSearchResultHandler(){ |
| } |
| |
| // ---------------------------------------------------------------------------- |
| TextTrieMap::TextTrieMap(UBool ignoreCase) |
| : fIgnoreCase(ignoreCase), fNodes(NULL), fNodesCapacity(0), fNodesCount(0), |
| fLazyContents(NULL), fIsEmpty(TRUE) { |
| } |
| |
| TextTrieMap::~TextTrieMap() { |
| int32_t index; |
| for (index = 0; index < fNodesCount; ++index) { |
| fNodes[index].deleteValues(); |
| } |
| uprv_free(fNodes); |
| if (fLazyContents != NULL) { |
| for (int32_t i=0; i<fLazyContents->size(); i+=2) { |
| ZoneStringInfo *zsinf = (ZoneStringInfo *)fLazyContents->elementAt(i+1); |
| delete zsinf; |
| } |
| delete fLazyContents; |
| } |
| } |
| |
| int32_t TextTrieMap::isEmpty() const { |
| // Use a separate field for fIsEmpty because it will remain unchanged once the |
| // Trie is built, while fNodes and fLazyContents change with the lazy init |
| // of the nodes structure. Trying to test the changing fields has |
| // thread safety complications. |
| return fIsEmpty; |
| } |
| |
| |
| // We defer actually building the TextTrieMap node structure until the first time a |
| // search is performed. put() simply saves the parameters in case we do |
| // eventually need to build it. |
| // |
| void |
| TextTrieMap::put(const UnicodeString &key, void *value, ZSFStringPool &sp, UErrorCode &status) { |
| fIsEmpty = FALSE; |
| if (fLazyContents == NULL) { |
| fLazyContents = new UVector(status); |
| if (fLazyContents == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| } |
| } |
| if (U_FAILURE(status)) { |
| return; |
| } |
| UChar *s = const_cast<UChar *>(sp.get(key, status)); |
| fLazyContents->addElement(s, status); |
| fLazyContents->addElement(value, status); |
| } |
| |
| |
| void |
| TextTrieMap::putImpl(const UnicodeString &key, void *value, UErrorCode &status) { |
| if (fNodes == NULL) { |
| fNodesCapacity = 512; |
| fNodes = (CharacterNode *)uprv_malloc(fNodesCapacity * sizeof(CharacterNode)); |
| fNodes[0].clear(); // Init root node. |
| fNodesCount = 1; |
| } |
| |
| UnicodeString foldedKey; |
| const UChar *keyBuffer; |
| int32_t keyLength; |
| if (fIgnoreCase) { |
| // Ok to use fastCopyFrom() because we discard the copy when we return. |
| foldedKey.fastCopyFrom(key).foldCase(); |
| keyBuffer = foldedKey.getBuffer(); |
| keyLength = foldedKey.length(); |
| } else { |
| keyBuffer = key.getBuffer(); |
| keyLength = key.length(); |
| } |
| |
| CharacterNode *node = fNodes; |
| int32_t index; |
| for (index = 0; index < keyLength; ++index) { |
| node = addChildNode(node, keyBuffer[index], status); |
| } |
| node->addValue(value, status); |
| } |
| |
| UBool |
| TextTrieMap::growNodes() { |
| if (fNodesCapacity == 0xffff) { |
| return FALSE; // We use 16-bit node indexes. |
| } |
| int32_t newCapacity = fNodesCapacity + 1000; |
| if (newCapacity > 0xffff) { |
| newCapacity = 0xffff; |
| } |
| CharacterNode *newNodes = (CharacterNode *)uprv_malloc(newCapacity * sizeof(CharacterNode)); |
| if (newNodes == NULL) { |
| return FALSE; |
| } |
| uprv_memcpy(newNodes, fNodes, fNodesCount * sizeof(CharacterNode)); |
| uprv_free(fNodes); |
| fNodes = newNodes; |
| fNodesCapacity = newCapacity; |
| return TRUE; |
| } |
| |
| CharacterNode* |
| TextTrieMap::addChildNode(CharacterNode *parent, UChar c, UErrorCode &status) { |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| // Linear search of the sorted list of children. |
| uint16_t prevIndex = 0; |
| uint16_t nodeIndex = parent->fFirstChild; |
| while (nodeIndex > 0) { |
| CharacterNode *current = fNodes + nodeIndex; |
| UChar childCharacter = current->fCharacter; |
| if (childCharacter == c) { |
| return current; |
| } else if (childCharacter > c) { |
| break; |
| } |
| prevIndex = nodeIndex; |
| nodeIndex = current->fNextSibling; |
| } |
| |
| // Ensure capacity. Grow fNodes[] if needed. |
| if (fNodesCount == fNodesCapacity) { |
| int32_t parentIndex = (int32_t)(parent - fNodes); |
| if (!growNodes()) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| parent = fNodes + parentIndex; |
| } |
| |
| // Insert a new child node with c in sorted order. |
| CharacterNode *node = fNodes + fNodesCount; |
| node->clear(); |
| node->fCharacter = c; |
| node->fNextSibling = nodeIndex; |
| if (prevIndex == 0) { |
| parent->fFirstChild = (uint16_t)fNodesCount; |
| } else { |
| fNodes[prevIndex].fNextSibling = (uint16_t)fNodesCount; |
| } |
| ++fNodesCount; |
| return node; |
| } |
| |
| CharacterNode* |
| TextTrieMap::getChildNode(CharacterNode *parent, UChar c) const { |
| // Linear search of the sorted list of children. |
| uint16_t nodeIndex = parent->fFirstChild; |
| while (nodeIndex > 0) { |
| CharacterNode *current = fNodes + nodeIndex; |
| UChar childCharacter = current->fCharacter; |
| if (childCharacter == c) { |
| return current; |
| } else if (childCharacter > c) { |
| break; |
| } |
| nodeIndex = current->fNextSibling; |
| } |
| return NULL; |
| } |
| |
| // Mutex for protecting the lazy creation of the Trie node structure on the first call to search(). |
| static UMTX TextTrieMutex; |
| |
| // buildTrie() - The Trie node structure is needed. Create it from the data that was |
| // saved at the time the ZoneStringFormatter was created. The Trie is only |
| // needed for parsing operations, which are less common than formatting, |
| // and the Trie is big, which is why its creation is deferred until first use. |
| void TextTrieMap::buildTrie(UErrorCode &status) { |
| umtx_lock(&TextTrieMutex); |
| if (fLazyContents != NULL) { |
| for (int32_t i=0; i<fLazyContents->size(); i+=2) { |
| const UChar *key = (UChar *)fLazyContents->elementAt(i); |
| void *val = fLazyContents->elementAt(i+1); |
| UnicodeString keyString(TRUE, key, -1); // Aliasing UnicodeString constructor. |
| putImpl(keyString, val, status); |
| } |
| delete fLazyContents; |
| fLazyContents = NULL; |
| } |
| umtx_unlock(&TextTrieMutex); |
| } |
| |
| |
| void |
| TextTrieMap::search(const UnicodeString &text, int32_t start, |
| TextTrieMapSearchResultHandler *handler, UErrorCode &status) const { |
| UBool trieNeedsInitialization = FALSE; |
| UMTX_CHECK(&TextTrieMutex, fLazyContents != NULL, trieNeedsInitialization); |
| if (trieNeedsInitialization) { |
| TextTrieMap *nonConstThis = const_cast<TextTrieMap *>(this); |
| nonConstThis->buildTrie(status); |
| } |
| if (fNodes == NULL) { |
| return; |
| } |
| search(fNodes, text, start, start, handler, status); |
| } |
| |
| void |
| TextTrieMap::search(CharacterNode *node, const UnicodeString &text, int32_t start, |
| int32_t index, TextTrieMapSearchResultHandler *handler, UErrorCode &status) const { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| if (node->hasValues()) { |
| if (!handler->handleMatch(index - start, node, status)) { |
| return; |
| } |
| if (U_FAILURE(status)) { |
| return; |
| } |
| } |
| UChar32 c = text.char32At(index); |
| if (fIgnoreCase) { |
| // size of character may grow after fold operation |
| UnicodeString tmp(c); |
| tmp.foldCase(); |
| int32_t tmpidx = 0; |
| while (tmpidx < tmp.length()) { |
| c = tmp.char32At(tmpidx); |
| node = getChildNode(node, c); |
| if (node == NULL) { |
| break; |
| } |
| tmpidx = tmp.moveIndex32(tmpidx, 1); |
| } |
| } else { |
| node = getChildNode(node, c); |
| } |
| if (node != NULL) { |
| search(node, text, start, index+1, handler, status); |
| } |
| } |
| |
| // ---------------------------------------------------------------------------- |
| ZoneStringInfo::ZoneStringInfo(const UnicodeString &id, const UnicodeString &str, |
| TimeZoneTranslationType type, ZSFStringPool &sp, UErrorCode &status) |
| : fType(type) { |
| fId = sp.get(id, status); |
| fStr = sp.get(str, status); |
| } |
| |
| ZoneStringInfo::~ZoneStringInfo() { |
| } |
| |
| |
| // ---------------------------------------------------------------------------- |
| ZoneStringSearchResultHandler::ZoneStringSearchResultHandler(UErrorCode &status) |
| : fResults(status) |
| { |
| clear(); |
| } |
| |
| ZoneStringSearchResultHandler::~ZoneStringSearchResultHandler() { |
| clear(); |
| } |
| |
| UBool |
| ZoneStringSearchResultHandler::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++) { |
| ZoneStringInfo *zsinfo = (ZoneStringInfo*)node->getValue(i); |
| if (zsinfo == NULL) { |
| break; |
| } |
| // Update the results |
| UBool foundType = FALSE; |
| for (int32_t j = 0; j < fResults.size(); j++) { |
| ZoneStringInfo *tmp = (ZoneStringInfo*)fResults.elementAt(j); |
| if (zsinfo->fType == tmp->fType) { |
| int32_t lenidx = getTimeZoneTranslationTypeIndex(tmp->fType); |
| if (matchLength > fMatchLen[lenidx]) { |
| // Same type, longer match |
| fResults.setElementAt(zsinfo, j); |
| fMatchLen[lenidx] = matchLength; |
| } |
| foundType = TRUE; |
| break; |
| } |
| } |
| if (!foundType) { |
| // not found in the current list |
| fResults.addElement(zsinfo, status); |
| fMatchLen[getTimeZoneTranslationTypeIndex(zsinfo->fType)] = matchLength; |
| } |
| } |
| } |
| return TRUE; |
| } |
| |
| int32_t |
| ZoneStringSearchResultHandler::countMatches(void) { |
| return fResults.size(); |
| } |
| |
| const ZoneStringInfo* |
| ZoneStringSearchResultHandler::getMatch(int32_t index, int32_t &matchLength) { |
| ZoneStringInfo *zsinfo = NULL; |
| if (index < fResults.size()) { |
| zsinfo = (ZoneStringInfo*)fResults.elementAt(index); |
| matchLength = fMatchLen[getTimeZoneTranslationTypeIndex(zsinfo->fType)]; |
| } |
| return zsinfo; |
| } |
| |
| void |
| ZoneStringSearchResultHandler::clear(void) { |
| fResults.removeAllElements(); |
| for (int32_t i = 0; i < (int32_t)(sizeof(fMatchLen)/sizeof(fMatchLen[0])); i++) { |
| fMatchLen[i] = 0; |
| } |
| } |
| |
| // Mutex for protecting the lazy load of a zone ID (or a full load) to ZoneStringFormat structures. |
| static UMTX ZoneStringFormatMutex; |
| |
| |
| // ---------------------------------------------------------------------------- |
| ZoneStringFormat::ZoneStringFormat(const UnicodeString* const* strings, |
| int32_t rowCount, int32_t columnCount, UErrorCode &status) |
| : fLocale(""), |
| fTzidToStrings(NULL), |
| fMzidToStrings(NULL), |
| fZoneStringsTrie(TRUE), |
| fStringPool(status), |
| fZoneStringsArray(NULL), |
| fMetazoneItem(NULL), |
| fZoneItem(NULL), |
| fIsFullyLoaded(FALSE) |
| { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| fLocale.setToBogus(); |
| if (strings == NULL || columnCount <= 0 || rowCount <= 0) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| fTzidToStrings = uhash_open(uhash_hashUChars, // key hash function |
| uhash_compareUChars, // key comparison function |
| NULL, // Value comparison function |
| &status); |
| fMzidToStrings = uhash_open(uhash_hashUChars, |
| uhash_compareUChars, |
| NULL, |
| &status); |
| |
| uhash_setValueDeleter(fTzidToStrings, deleteZoneStrings); |
| uhash_setValueDeleter(fMzidToStrings, deleteZoneStrings); |
| |
| for (int32_t row = 0; row < rowCount; row++) { |
| if (strings[row][0].isEmpty()) { |
| continue; |
| } |
| UnicodeString *names = new UnicodeString[ZSIDX_COUNT]; |
| for (int32_t col = 1; col < columnCount; col++) { |
| if (!strings[row][col].isEmpty()) { |
| int32_t typeIdx = -1; |
| switch (col) { |
| case 1: |
| typeIdx = ZSIDX_LONG_STANDARD; |
| break; |
| case 2: |
| typeIdx = ZSIDX_SHORT_STANDARD; |
| break; |
| case 3: |
| typeIdx = ZSIDX_LONG_DAYLIGHT; |
| break; |
| case 4: |
| typeIdx = ZSIDX_SHORT_DAYLIGHT; |
| break; |
| case 5: |
| typeIdx = ZSIDX_LOCATION; |
| break; |
| case 6: |
| typeIdx = ZSIDX_LONG_GENERIC; |
| break; |
| case 7: |
| typeIdx = ZSIDX_SHORT_GENERIC; |
| break; |
| } |
| if (typeIdx != -1) { |
| names[typeIdx].setTo(strings[row][col]); |
| |
| // Put the name into the trie |
| int32_t type = getTimeZoneTranslationType((TimeZoneTranslationTypeIndex)typeIdx); |
| ZoneStringInfo *zsinf = new ZoneStringInfo(strings[row][0], |
| strings[row][col], |
| (TimeZoneTranslationType)type, |
| fStringPool, |
| status); |
| fZoneStringsTrie.put(strings[row][col], zsinf, fStringPool, status); |
| if (U_FAILURE(status)) { |
| delete zsinf; |
| goto error_cleanup; |
| } |
| } |
| } |
| } |
| // Note: ZoneStrings constructor adopts and delete the names array. |
| ZoneStrings *zstrings = new ZoneStrings(names, ZSIDX_COUNT, TRUE, NULL, 0, 0, |
| fStringPool, status); |
| UChar *utzid = const_cast<UChar *>(fStringPool.get(strings[row][0], status)); |
| uhash_put(fTzidToStrings, utzid, zstrings, &status); |
| if (U_FAILURE(status)) { |
| delete zstrings; |
| goto error_cleanup; |
| } |
| } |
| fStringPool.freeze(); |
| fIsFullyLoaded = TRUE; |
| return; |
| |
| error_cleanup: |
| return; |
| } |
| |
| ZoneStringFormat::ZoneStringFormat(const Locale &locale, UErrorCode &status) |
| : fLocale(locale), |
| fTzidToStrings(NULL), |
| fMzidToStrings(NULL), |
| fZoneStringsTrie(TRUE), |
| fStringPool(status), |
| fZoneStringsArray(NULL), |
| fMetazoneItem(NULL), |
| fZoneItem(NULL), |
| fIsFullyLoaded(FALSE) |
| { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| fTzidToStrings = uhash_open(uhash_hashUChars, // key hash function |
| uhash_compareUChars, // key comparison function |
| NULL, // Value comparison function |
| &status); |
| fMzidToStrings = uhash_open(uhash_hashUChars, // key hash function |
| uhash_compareUChars, // key comparison function |
| NULL, // Value comparison function |
| &status); |
| uhash_setValueDeleter(fTzidToStrings, deleteZoneStrings); |
| uhash_setValueDeleter(fMzidToStrings, deleteZoneStrings); |
| } |
| |
| // Load only a single zone |
| void |
| ZoneStringFormat::loadZone(const UnicodeString &utzid, UErrorCode &status) |
| { |
| if (fIsFullyLoaded) { |
| return; |
| } |
| |
| if (U_FAILURE(status)) { |
| return; |
| } |
| |
| umtx_lock(&ZoneStringFormatMutex); |
| |
| if (fZoneStringsArray == NULL) { |
| fZoneStringsArray = ures_open(U_ICUDATA_ZONE, fLocale.getName(), &status); |
| fZoneStringsArray = ures_getByKeyWithFallback(fZoneStringsArray, gZoneStringsTag, fZoneStringsArray, &status); |
| if (U_FAILURE(status)) { |
| // If no locale bundles are available, zoneStrings will be null. |
| // We still want to go through the rest of zone strings initialization, |
| // because generic location format is generated from tzid for the case. |
| // The rest of code should work even zoneStrings is null. |
| status = U_ZERO_ERROR; |
| ures_close(fZoneStringsArray); |
| fZoneStringsArray = NULL; |
| } |
| } |
| |
| // Skip non-canonical IDs |
| UnicodeString canonicalID; |
| TimeZone::getCanonicalID(utzid, canonicalID, status); |
| if (U_FAILURE(status)) { |
| // Ignore unknown ID - we should not get here, but just in case. |
| // status = U_ZERO_ERROR; |
| umtx_unlock(&ZoneStringFormatMutex); |
| return; |
| } |
| |
| if (U_SUCCESS(status)) { |
| if (uhash_count(fTzidToStrings) > 0) { |
| ZoneStrings *zstrings = (ZoneStrings*)uhash_get(fTzidToStrings, canonicalID.getTerminatedBuffer()); |
| if (zstrings != NULL) { |
| umtx_unlock(&ZoneStringFormatMutex); |
| return; // We already about this one |
| } |
| } |
| } |
| |
| addSingleZone(canonicalID, status); |
| |
| umtx_unlock(&ZoneStringFormatMutex); |
| } |
| |
| // Load only a single zone |
| void |
| ZoneStringFormat::addSingleZone(UnicodeString &utzid, UErrorCode &status) |
| { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| |
| if (uhash_count(fTzidToStrings) > 0) { |
| ZoneStrings *zstrings = (ZoneStrings*)uhash_get(fTzidToStrings, utzid.getTerminatedBuffer()); |
| if (zstrings != NULL) { |
| return; // We already about this one |
| } |
| } |
| |
| MessageFormat *fallbackFmt = NULL; |
| MessageFormat *regionFmt = NULL; |
| |
| fallbackFmt = getFallbackFormat(fLocale, status); |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| regionFmt = getRegionFormat(fLocale, status); |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| |
| |
| { |
| char zidkey[ZID_KEY_MAX+1]; |
| char tzid[ZID_KEY_MAX+1]; |
| utzid.extract(0, utzid.length(), zidkey, ZID_KEY_MAX, US_INV); |
| utzid.extract(0, utzid.length(), tzid, ZID_KEY_MAX, US_INV); |
| |
| const UChar *zstrarray[ZSIDX_COUNT]; |
| const UChar *mzstrarray[ZSIDX_COUNT]; |
| UnicodeString mzPartialLoc[MAX_METAZONES_PER_ZONE][4]; |
| |
| // Replace '/' with ':' |
| char *pCity = NULL; |
| char *p = zidkey; |
| while (*p) { |
| if (*p == '/') { |
| *p = ':'; |
| pCity = p + 1; |
| } |
| p++; |
| } |
| |
| if (fZoneStringsArray != NULL) { |
| fZoneItem = ures_getByKeyWithFallback(fZoneStringsArray, zidkey, fZoneItem, &status); |
| if (U_FAILURE(status)) { |
| // If failed to open the zone item, create only location string |
| ures_close(fZoneItem); |
| fZoneItem = NULL; |
| status = U_ZERO_ERROR; |
| } |
| } |
| |
| UnicodeString region; |
| getRegion(region); |
| |
| zstrarray[ZSIDX_LONG_STANDARD] = getZoneStringFromBundle(fZoneItem, gLongStandardTag); |
| zstrarray[ZSIDX_SHORT_STANDARD] = getZoneStringFromBundle(fZoneItem, gShortStandardTag); |
| zstrarray[ZSIDX_LONG_DAYLIGHT] = getZoneStringFromBundle(fZoneItem, gLongDaylightTag); |
| zstrarray[ZSIDX_SHORT_DAYLIGHT] = getZoneStringFromBundle(fZoneItem, gShortDaylightTag); |
| zstrarray[ZSIDX_LONG_GENERIC] = getZoneStringFromBundle(fZoneItem, gLongGenericTag); |
| zstrarray[ZSIDX_SHORT_GENERIC] = getZoneStringFromBundle(fZoneItem, gShortGenericTag); |
| |
| // Compose location format string |
| UnicodeString location; |
| UnicodeString country; |
| UnicodeString city; |
| UnicodeString countryCode; |
| ZoneMeta::getCanonicalCountry(utzid, countryCode); |
| if (!countryCode.isEmpty()) { |
| const UChar* tmpCity = getZoneStringFromBundle(fZoneItem, gExemplarCityTag); |
| if (tmpCity != NULL) { |
| city.setTo(TRUE, tmpCity, -1); |
| } else { |
| city.setTo(UnicodeString(pCity, -1, US_INV)); |
| // Replace '_' with ' ' |
| for (int32_t i = 0; i < city.length(); i++) { |
| if (city.charAt(i) == (UChar)0x5F /*'_'*/) { |
| city.setCharAt(i, (UChar)0x20 /*' '*/); |
| } |
| } |
| } |
| getLocalizedCountry(countryCode, fLocale, country); |
| UnicodeString singleCountry; |
| ZoneMeta::getSingleCountry(utzid, singleCountry); |
| FieldPosition fpos; |
| if (singleCountry.isEmpty()) { |
| Formattable params [] = { |
| Formattable(city), |
| Formattable(country) |
| }; |
| fallbackFmt->format(params, 2, location, fpos, status); |
| } else { |
| // If the zone is only one zone in the country, do not add city |
| Formattable params [] = { |
| Formattable(country) |
| }; |
| regionFmt->format(params, 1, location, fpos, status); |
| } |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| |
| zstrarray[ZSIDX_LOCATION] = location.getTerminatedBuffer(); |
| } else { |
| if (uprv_strlen(tzid) > 4 && uprv_strncmp(tzid, "Etc/", 4) == 0) { |
| // "Etc/xxx" is not associated with a specific location, so localized |
| // GMT format is always used as generic location format. |
| zstrarray[ZSIDX_LOCATION] = NULL; |
| } else { |
| // When a new time zone ID, which is actually associated with a specific |
| // location, is added in tzdata, but the current CLDR data does not have |
| // the information yet, ICU creates a generic location string based on |
| // the ID. This implementation supports canonical time zone round trip |
| // with format pattern "VVVV". See #6602 for the details. |
| UnicodeString loc(utzid); |
| int32_t slashIdx = loc.lastIndexOf((UChar)0x2f); |
| if (slashIdx == -1) { |
| // A time zone ID without slash in the tz database is not |
| // associated with a specific location. For instances, |
| // MET, CET, EET and WET fall into this category. |
| // In this case, we still use GMT format as fallback. |
| zstrarray[ZSIDX_LOCATION] = NULL; |
| } else { |
| FieldPosition fpos; |
| Formattable params[] = { |
| Formattable(loc) |
| }; |
| regionFmt->format(params, 1, location, fpos, status); |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| zstrarray[ZSIDX_LOCATION] = location.getTerminatedBuffer(); |
| } |
| } |
| } |
| |
| UBool commonlyUsed = isCommonlyUsed(fZoneItem); |
| |
| // Resolve metazones used by this zone |
| int32_t mzPartialLocIdx = 0; |
| const UVector *metazoneMappings = ZoneMeta::getMetazoneMappings(utzid); |
| if (metazoneMappings != NULL) { |
| for (int32_t i = 0; i < metazoneMappings->size(); i++) { |
| const OlsonToMetaMappingEntry *mzmap = |
| (const OlsonToMetaMappingEntry*)metazoneMappings->elementAt(i); |
| UnicodeString mzid(mzmap->mzid); |
| const ZoneStrings *mzStrings = |
| (const ZoneStrings*)uhash_get(fMzidToStrings, mzid.getTerminatedBuffer()); |
| if (mzStrings == NULL) { |
| // If the metazone strings are not yet processed, do it now. |
| char mzidkey[ZID_KEY_MAX]; |
| uprv_strcpy(mzidkey, gMetazoneIdPrefix); |
| u_UCharsToChars(mzmap->mzid, mzidkey + MZID_PREFIX_LEN, u_strlen(mzmap->mzid) + 1); |
| fMetazoneItem = ures_getByKeyWithFallback(fZoneStringsArray, mzidkey, fMetazoneItem, &status); |
| if (U_FAILURE(status)) { |
| // No resources available for this metazone |
| // Resource bundle will be cleaned up after end of the loop. |
| status = U_ZERO_ERROR; |
| continue; |
| } |
| UBool mzCommonlyUsed = isCommonlyUsed(fMetazoneItem); |
| mzstrarray[ZSIDX_LONG_STANDARD] = getZoneStringFromBundle(fMetazoneItem, gLongStandardTag); |
| mzstrarray[ZSIDX_SHORT_STANDARD] = getZoneStringFromBundle(fMetazoneItem, gShortStandardTag); |
| mzstrarray[ZSIDX_LONG_DAYLIGHT] = getZoneStringFromBundle(fMetazoneItem, gLongDaylightTag); |
| mzstrarray[ZSIDX_SHORT_DAYLIGHT] = getZoneStringFromBundle(fMetazoneItem, gShortDaylightTag); |
| mzstrarray[ZSIDX_LONG_GENERIC] = getZoneStringFromBundle(fMetazoneItem, gLongGenericTag); |
| mzstrarray[ZSIDX_SHORT_GENERIC] = getZoneStringFromBundle(fMetazoneItem, gShortGenericTag); |
| mzstrarray[ZSIDX_LOCATION] = NULL; |
| |
| int32_t lastNonNullIdx = ZSIDX_COUNT - 1; |
| while (lastNonNullIdx >= 0) { |
| if (mzstrarray[lastNonNullIdx] != NULL) { |
| break; |
| } |
| lastNonNullIdx--; |
| } |
| UnicodeString *strings_mz = NULL; |
| ZoneStrings *tmp_mzStrings = NULL; |
| if (lastNonNullIdx >= 0) { |
| // Create UnicodeString array and put strings to the zone string trie |
| strings_mz = new UnicodeString[lastNonNullIdx + 1]; |
| |
| UnicodeString preferredIdForLocale; |
| ZoneMeta::getZoneIdByMetazone(mzid, region, preferredIdForLocale); |
| |
| for (int32_t typeidx = 0; typeidx <= lastNonNullIdx; typeidx++) { |
| if (mzstrarray[typeidx] != NULL) { |
| strings_mz[typeidx].setTo(TRUE, mzstrarray[typeidx], -1); |
| |
| // Add a metazone string to the zone string trie |
| int32_t type = getTimeZoneTranslationType((TimeZoneTranslationTypeIndex)typeidx); |
| ZoneStringInfo *zsinfo = new ZoneStringInfo( |
| preferredIdForLocale, |
| strings_mz[typeidx], |
| (TimeZoneTranslationType)type, |
| fStringPool, |
| status); |
| fZoneStringsTrie.put(strings_mz[typeidx], zsinfo, fStringPool, status); |
| if (U_FAILURE(status)) { |
| delete []strings_mz; |
| goto error_cleanup; |
| } |
| } |
| } |
| // Note: ZoneStrings constructor adopts and deletes the strings_mz array. |
| tmp_mzStrings = new ZoneStrings(strings_mz, lastNonNullIdx + 1, |
| mzCommonlyUsed, NULL, 0, 0, fStringPool, status); |
| } else { |
| // Create ZoneStrings with empty contents |
| tmp_mzStrings = new ZoneStrings(NULL, 0, FALSE, NULL, 0, 0, fStringPool, status); |
| } |
| |
| UChar *umzid = const_cast<UChar *>(fStringPool.get(mzid, status)); |
| uhash_put(fMzidToStrings, umzid, tmp_mzStrings, &status); |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| |
| mzStrings = tmp_mzStrings; |
| } |
| |
| // Compose generic partial location format |
| UnicodeString lg; |
| UnicodeString sg; |
| |
| mzStrings->getString(ZSIDX_LONG_GENERIC, lg); |
| mzStrings->getString(ZSIDX_SHORT_GENERIC, sg); |
| |
| if (!lg.isEmpty() || !sg.isEmpty()) { |
| UBool addMzPartialLocationNames = TRUE; |
| for (int32_t j = 0; j < mzPartialLocIdx; j++) { |
| if (mzPartialLoc[j][0] == mzid) { |
| // already processed |
| addMzPartialLocationNames = FALSE; |
| break; |
| } |
| } |
| if (addMzPartialLocationNames) { |
| UnicodeString *locationPart = NULL; |
| // Check if the zone is the preferred zone for the territory associated with the zone |
| UnicodeString preferredID; |
| ZoneMeta::getZoneIdByMetazone(mzid, countryCode, preferredID); |
| if (utzid == preferredID) { |
| // Use country for the location |
| locationPart = &country; |
| } else { |
| // Use city for the location |
| locationPart = &city; |
| } |
| // Reset the partial location string array |
| mzPartialLoc[mzPartialLocIdx][0].setTo(mzid); |
| mzPartialLoc[mzPartialLocIdx][1].remove(); |
| mzPartialLoc[mzPartialLocIdx][2].remove(); |
| mzPartialLoc[mzPartialLocIdx][3].remove(); |
| |
| if (locationPart->length() != 0) { |
| FieldPosition fpos; |
| if (!lg.isEmpty()) { |
| Formattable params [] = { |
| Formattable(*locationPart), |
| Formattable(lg) |
| }; |
| fallbackFmt->format(params, 2, mzPartialLoc[mzPartialLocIdx][1], fpos, status); |
| } |
| if (!sg.isEmpty()) { |
| Formattable params [] = { |
| Formattable(*locationPart), |
| Formattable(sg) |
| }; |
| fallbackFmt->format(params, 2, mzPartialLoc[mzPartialLocIdx][2], fpos, status); |
| if (mzStrings->isShortFormatCommonlyUsed()) { |
| mzPartialLoc[mzPartialLocIdx][3].setTo(TRUE, gCommonlyUsedTrue, -1); |
| } |
| } |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| } |
| mzPartialLocIdx++; |
| } |
| } |
| } |
| } |
| // Collected names for a zone |
| |
| // Create UnicodeString array for localized zone strings |
| int32_t lastIdx = ZSIDX_COUNT - 1; |
| while (lastIdx >= 0) { |
| if (zstrarray[lastIdx] != NULL) { |
| break; |
| } |
| lastIdx--; |
| } |
| UnicodeString *strings = NULL; |
| int32_t stringsCount = lastIdx + 1; |
| |
| if (stringsCount > 0) { |
| strings = new UnicodeString[stringsCount]; |
| for (int32_t i = 0; i < stringsCount; i++) { |
| if (zstrarray[i] != NULL) { |
| strings[i].setTo(zstrarray[i], -1); |
| |
| // Add names to the trie |
| int32_t type = getTimeZoneTranslationType((TimeZoneTranslationTypeIndex)i); |
| ZoneStringInfo *zsinfo = new ZoneStringInfo(utzid, |
| strings[i], |
| (TimeZoneTranslationType)type, |
| fStringPool, |
| status); |
| fZoneStringsTrie.put(strings[i], zsinfo, fStringPool, status); |
| if (U_FAILURE(status)) { |
| delete zsinfo; |
| delete[] strings; |
| goto error_cleanup; |
| } |
| } |
| } |
| } |
| |
| // Create UnicodeString array for generic partial location strings |
| UnicodeString **genericPartialLocationNames = NULL; |
| int32_t genericPartialRowCount = mzPartialLocIdx; |
| int32_t genericPartialColCount = 4; |
| |
| if (genericPartialRowCount != 0) { |
| genericPartialLocationNames = |
| (UnicodeString**)uprv_malloc(genericPartialRowCount * sizeof(UnicodeString*)); |
| if (genericPartialLocationNames == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| delete[] strings; |
| goto error_cleanup; |
| } |
| for (int32_t i = 0; i < genericPartialRowCount; i++) { |
| genericPartialLocationNames[i] = new UnicodeString[genericPartialColCount]; |
| for (int32_t j = 0; j < genericPartialColCount; j++) { |
| genericPartialLocationNames[i][j].setTo(mzPartialLoc[i][j]); |
| // Add names to the trie |
| if ((j == 1 || j == 2) &&!genericPartialLocationNames[i][j].isEmpty()) { |
| ZoneStringInfo *zsinfo; |
| TimeZoneTranslationType type = (j == 1) ? GENERIC_LONG : GENERIC_SHORT; |
| zsinfo = new ZoneStringInfo(utzid, genericPartialLocationNames[i][j], type, |
| fStringPool, status); |
| fZoneStringsTrie.put(genericPartialLocationNames[i][j], zsinfo, fStringPool, status); |
| if (U_FAILURE(status)) { |
| delete[] genericPartialLocationNames[i]; |
| uprv_free(genericPartialLocationNames); |
| delete[] strings; |
| goto error_cleanup; |
| } |
| } |
| } |
| } |
| } |
| |
| // Finally, create ZoneStrings instance and put it into the tzidToStinrgs map |
| ZoneStrings *zstrings = new ZoneStrings(strings, stringsCount, commonlyUsed, |
| genericPartialLocationNames, genericPartialRowCount, |
| genericPartialColCount, fStringPool, status); |
| |
| UChar *uutzid = const_cast<UChar *>(fStringPool.get(utzid, status)); |
| uhash_put(fTzidToStrings, uutzid, zstrings, &status); |
| if (U_FAILURE(status)) { |
| delete zstrings; |
| goto error_cleanup; |
| } |
| } |
| |
| error_cleanup: |
| if (fallbackFmt != NULL) { |
| delete fallbackFmt; |
| } |
| if (regionFmt != NULL) { |
| delete regionFmt; |
| } |
| // fStringPool.freeze(); |
| } |
| |
| void |
| ZoneStringFormat::loadFull(UErrorCode &status) |
| { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| if (fIsFullyLoaded) { |
| return; |
| } |
| |
| umtx_lock(&ZoneStringFormatMutex); |
| |
| if (fZoneStringsArray == NULL) { |
| fZoneStringsArray = ures_open(U_ICUDATA_ZONE, fLocale.getName(), &status); |
| fZoneStringsArray = ures_getByKeyWithFallback(fZoneStringsArray, gZoneStringsTag, fZoneStringsArray, &status); |
| if (U_FAILURE(status)) { |
| // If no locale bundles are available, zoneStrings will be null. |
| // We still want to go through the rest of zone strings initialization, |
| // because generic location format is generated from tzid for the case. |
| // The rest of code should work even zoneStrings is null. |
| status = U_ZERO_ERROR; |
| ures_close(fZoneStringsArray); |
| fZoneStringsArray = NULL; |
| } |
| } |
| |
| StringEnumeration *tzids = NULL; |
| |
| tzids = TimeZone::createEnumeration(); |
| const char *tzid; |
| while ((tzid = tzids->next(NULL, status))) { |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| // Skip non-canonical IDs |
| UnicodeString utzid(tzid, -1, US_INV); |
| UnicodeString canonicalID; |
| TimeZone::getCanonicalID(utzid, canonicalID, status); |
| if (U_FAILURE(status)) { |
| // Ignore unknown ID - we should not get here, but just in case. |
| status = U_ZERO_ERROR; |
| continue; |
| } |
| |
| if (U_SUCCESS(status)) { |
| if (uhash_count(fTzidToStrings) > 0) { |
| ZoneStrings *zstrings = (ZoneStrings*)uhash_get(fTzidToStrings, canonicalID.getTerminatedBuffer()); |
| if (zstrings != NULL) { |
| continue; // We already about this one |
| } |
| } |
| } |
| |
| addSingleZone(canonicalID, status); |
| |
| if (U_FAILURE(status)) { |
| goto error_cleanup; |
| } |
| } |
| |
| fIsFullyLoaded = TRUE; |
| |
| error_cleanup: |
| if (tzids != NULL) { |
| delete tzids; |
| } |
| fStringPool.freeze(); |
| |
| umtx_unlock(&ZoneStringFormatMutex); |
| } |
| |
| |
| ZoneStringFormat::~ZoneStringFormat() { |
| uhash_close(fTzidToStrings); |
| uhash_close(fMzidToStrings); |
| ures_close(fZoneItem); |
| ures_close(fMetazoneItem); |
| ures_close(fZoneStringsArray); |
| } |
| |
| SafeZoneStringFormatPtr* |
| ZoneStringFormat::getZoneStringFormat(const Locale& locale, UErrorCode &status) { |
| umtx_lock(&gZSFCacheLock); |
| if (gZoneStringFormatCache == NULL) { |
| gZoneStringFormatCache = new ZSFCache(10 /* capacity */); |
| ucln_i18n_registerCleanup(UCLN_I18N_ZSFORMAT, zoneStringFormat_cleanup); |
| } |
| umtx_unlock(&gZSFCacheLock); |
| |
| return gZoneStringFormatCache->get(locale, status); |
| } |
| |
| |
| UnicodeString** |
| ZoneStringFormat::createZoneStringsArray(UDate date, int32_t &rowCount, int32_t &colCount, UErrorCode &status) const { |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| ZoneStringFormat *nonConstThis = const_cast<ZoneStringFormat *>(this); |
| nonConstThis->loadFull(status); |
| |
| UnicodeString **result = NULL; |
| rowCount = 0; |
| colCount = 0; |
| |
| // Collect canonical time zone IDs |
| UVector canonicalIDs(uhash_deleteUnicodeString, uhash_compareUnicodeString, status); |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| StringEnumeration *tzids = TimeZone::createEnumeration(); |
| const UChar *tzid; |
| while ((tzid = tzids->unext(NULL, status))) { |
| if (U_FAILURE(status)) { |
| delete tzids; |
| return NULL; |
| } |
| UnicodeString utzid(tzid); |
| UnicodeString canonicalID; |
| TimeZone::getCanonicalID(UnicodeString(tzid), canonicalID, status); |
| if (U_FAILURE(status)) { |
| // Ignore unknown ID - we should not get here, but just in case. |
| status = U_ZERO_ERROR; |
| continue; |
| } |
| if (utzid == canonicalID) { |
| canonicalIDs.addElement(new UnicodeString(utzid), status); |
| if (U_FAILURE(status)) { |
| delete tzids; |
| return NULL; |
| } |
| } |
| } |
| delete tzids; |
| |
| // Allocate array |
| result = (UnicodeString**)uprv_malloc(canonicalIDs.size() * sizeof(UnicodeString*)); |
| if (result == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| for (int32_t i = 0; i < canonicalIDs.size(); i++) { |
| result[i] = new UnicodeString[8]; |
| UnicodeString *id = (UnicodeString*)canonicalIDs.elementAt(i); |
| result[i][0].setTo(*id); |
| getLongStandard(*id, date, result[i][1]); |
| getShortStandard(*id, date, FALSE, result[i][2]); |
| getLongDaylight(*id, date, result[i][3]); |
| getShortDaylight(*id, date, FALSE, result[i][4]); |
| getGenericLocation(*id, result[i][5]); |
| getLongGenericNonLocation(*id, date, result[i][6]); |
| getShortGenericNonLocation(*id, date, FALSE, result[i][7]); |
| } |
| |
| rowCount = canonicalIDs.size(); |
| colCount = 8; |
| return result; |
| } |
| |
| UnicodeString& |
| ZoneStringFormat::getSpecificLongString(const Calendar &cal, UnicodeString &result, |
| UErrorCode &status) const { |
| result.remove(); |
| if (U_FAILURE(status)) { |
| return result; |
| } |
| UnicodeString tzid; |
| cal.getTimeZone().getID(tzid); |
| UDate date = cal.getTime(status); |
| if (cal.get(UCAL_DST_OFFSET, status) == 0) { |
| return getString(tzid, ZSIDX_LONG_STANDARD, date, FALSE /*not used*/, result); |
| } else { |
| return getString(tzid, ZSIDX_LONG_DAYLIGHT, date, FALSE /*not used*/, result); |
| } |
| } |
| |
| UnicodeString& |
| ZoneStringFormat::getSpecificShortString(const Calendar &cal, UBool commonlyUsedOnly, |
| UnicodeString &result, UErrorCode &status) const { |
| result.remove(); |
| if (U_FAILURE(status)) { |
| return result; |
| } |
| UnicodeString tzid; |
| cal.getTimeZone().getID(tzid); |
| UDate date = cal.getTime(status); |
| if (cal.get(UCAL_DST_OFFSET, status) == 0) { |
| return getString(tzid, ZSIDX_SHORT_STANDARD, date, commonlyUsedOnly, result); |
| } else { |
| return getString(tzid, ZSIDX_SHORT_DAYLIGHT, date, commonlyUsedOnly, result); |
| } |
| } |
| |
| UnicodeString& |
| ZoneStringFormat::getGenericLongString(const Calendar &cal, UnicodeString &result, |
| UErrorCode &status) const { |
| return getGenericString(cal, FALSE /*long*/, FALSE /* not used */, result, status); |
| } |
| |
| UnicodeString& |
| ZoneStringFormat::getGenericShortString(const Calendar &cal, UBool commonlyUsedOnly, |
| UnicodeString &result, UErrorCode &status) const { |
| return getGenericString(cal, TRUE /*short*/, commonlyUsedOnly, result, status); |
| } |
| |
| UnicodeString& |
| ZoneStringFormat::getGenericLocationString(const Calendar &cal, UnicodeString &result, |
| UErrorCode &status) const { |
| UnicodeString tzid; |
| cal.getTimeZone().getID(tzid); |
| UDate date = cal.getTime(status); |
| return getString(tzid, ZSIDX_LOCATION, date, FALSE /*not used*/, result); |
| } |
| |
| const ZoneStringInfo* |
| ZoneStringFormat::findSpecificLong(const UnicodeString &text, int32_t start, |
| int32_t &matchLength, UErrorCode &status) const { |
| return find(text, start, STANDARD_LONG | DAYLIGHT_LONG, matchLength, status); |
| } |
| |
| const ZoneStringInfo* |
| ZoneStringFormat::findSpecificShort(const UnicodeString &text, int32_t start, |
| int32_t &matchLength, UErrorCode &status) const { |
| return find(text, start, STANDARD_SHORT | DAYLIGHT_SHORT, matchLength, status); |
| } |
| |
| const ZoneStringInfo* |
| ZoneStringFormat::findGenericLong(const UnicodeString &text, int32_t start, |
| int32_t &matchLength, UErrorCode &status) const { |
| return find(text, start, GENERIC_LONG | STANDARD_LONG | LOCATION, matchLength, status); |
| } |
| |
| const ZoneStringInfo* |
| ZoneStringFormat::findGenericShort(const UnicodeString &text, int32_t start, |
| int32_t &matchLength, UErrorCode &status) const { |
| return find(text, start, GENERIC_SHORT | STANDARD_SHORT | LOCATION, matchLength, status); |
| } |
| |
| const ZoneStringInfo* |
| ZoneStringFormat::findGenericLocation(const UnicodeString &text, int32_t start, |
| int32_t &matchLength, UErrorCode &status) const { |
| return find(text, start, LOCATION, matchLength, status); |
| } |
| |
| UnicodeString& |
| ZoneStringFormat::getString(const UnicodeString &tzid, TimeZoneTranslationTypeIndex typeIdx, UDate date, |
| UBool commonlyUsedOnly, UnicodeString& result) const { |
| UErrorCode status = U_ZERO_ERROR; |
| result.remove(); |
| if (!fIsFullyLoaded) { |
| // Lazy loading |
| ZoneStringFormat *nonConstThis = const_cast<ZoneStringFormat *>(this); |
| nonConstThis->loadZone(tzid, status); |
| } |
| |
| // ICU's own array does not have entries for aliases |
| UnicodeString canonicalID; |
| TimeZone::getCanonicalID(tzid, canonicalID, status); |
| if (U_FAILURE(status)) { |
| // Unknown ID, but users might have their own data. |
| canonicalID.setTo(tzid); |
| } |
| |
| if (uhash_count(fTzidToStrings) > 0) { |
| ZoneStrings *zstrings = (ZoneStrings*)uhash_get(fTzidToStrings, canonicalID.getTerminatedBuffer()); |
| if (zstrings != NULL) { |
| switch (typeIdx) { |
| case ZSIDX_LONG_STANDARD: |
| case ZSIDX_LONG_DAYLIGHT: |
| case ZSIDX_LONG_GENERIC: |
| case ZSIDX_LOCATION: |
| zstrings->getString(typeIdx, result); |
| break; |
| case ZSIDX_SHORT_STANDARD: |
| case ZSIDX_SHORT_DAYLIGHT: |
| case ZSIDX_COUNT: //added to avoid warning |
| case ZSIDX_SHORT_GENERIC: |
| if (!commonlyUsedOnly || zstrings->isShortFormatCommonlyUsed()) { |
| zstrings->getString(typeIdx, result); |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| if (result.isEmpty() && uhash_count(fMzidToStrings) > 0 && typeIdx != ZSIDX_LOCATION) { |
| // Try metazone |
| UnicodeString mzid; |
| ZoneMeta::getMetazoneID(canonicalID, date, mzid); |
| if (!mzid.isEmpty()) { |
| ZoneStrings *mzstrings = (ZoneStrings*)uhash_get(fMzidToStrings, mzid.getTerminatedBuffer()); |
| if (mzstrings != NULL) { |
| switch (typeIdx) { |
| case ZSIDX_LONG_STANDARD: |
| case ZSIDX_LONG_DAYLIGHT: |
| case ZSIDX_LONG_GENERIC: |
| case ZSIDX_LOCATION: |
| mzstrings->getString(typeIdx, result); |
| break; |
| case ZSIDX_SHORT_STANDARD: |
| case ZSIDX_SHORT_DAYLIGHT: |
| case ZSIDX_COUNT: //added to avoid warning |
| case ZSIDX_SHORT_GENERIC: |
| if (!commonlyUsedOnly || mzstrings->isShortFormatCommonlyUsed()) { |
| mzstrings->getString(typeIdx, result); |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| } |
| return result; |
| } |
| |
| UnicodeString& |
| ZoneStringFormat::getGenericString(const Calendar &cal, UBool isShort, UBool commonlyUsedOnly, |
| UnicodeString &result, UErrorCode &status) const { |
| result.remove(); |
| UDate time = cal.getTime(status); |
| if (U_FAILURE(status)) { |
| return result; |
| } |
| const TimeZone &tz = cal.getTimeZone(); |
| UnicodeString tzid; |
| tz.getID(tzid); |
| |
| if (!fIsFullyLoaded) { |
| // Lazy loading |
| ZoneStringFormat *nonConstThis = const_cast<ZoneStringFormat *>(this); |
| nonConstThis->loadZone(tzid, status); |
| } |
| |
| // ICU's own array does not have entries for aliases |
| UnicodeString canonicalID; |
| TimeZone::getCanonicalID(tzid, canonicalID, status); |
| if (U_FAILURE(status)) { |
| // Unknown ID, but users might have their own data. |
| status = U_ZERO_ERROR; |
| canonicalID.setTo(tzid); |
| } |
| |
| ZoneStrings *zstrings = NULL; |
| if (uhash_count(fTzidToStrings) > 0) { |
| zstrings = (ZoneStrings*)uhash_get(fTzidToStrings, canonicalID.getTerminatedBuffer()); |
| if (zstrings != NULL) { |
| if (isShort) { |
| if (!commonlyUsedOnly || zstrings->isShortFormatCommonlyUsed()) { |
| zstrings->getString(ZSIDX_SHORT_GENERIC, result); |
| } |
| } else { |
| zstrings->getString(ZSIDX_LONG_GENERIC, result); |
| } |
| } |
| } |
| if (result.isEmpty() && uhash_count(fMzidToStrings) > 0) { |
| // try metazone |
| int32_t raw, sav; |
| UnicodeString mzid; |
| ZoneMeta::getMetazoneID(canonicalID, time, mzid); |
| if (!mzid.isEmpty()) { |
| UBool useStandard = FALSE; |
| sav = cal.get(UCAL_DST_OFFSET, status); |
| if (U_FAILURE(status)) { |
| return result; |
| } |
| if (sav == 0) { |
| useStandard = TRUE; |
| // Check if the zone actually uses daylight saving time around the time |
| TimeZone *tmptz = tz.clone(); |
| 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(time, TRUE, before); |
| if (beforTrs |
| && (time - before.getTime() < kDstCheckRange) |
| && before.getFrom()->getDSTSavings() != 0) { |
| useStandard = FALSE; |
| } else { |
| TimeZoneTransition after; |
| UBool afterTrs = btz->getNextTransition(time, FALSE, after); |
| if (afterTrs |
| && (after.getTime() - time < 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(time - kDstCheckRange, FALSE, raw, sav, status); |
| if (sav != 0) { |
| useStandard = FALSE; |
| } else { |
| tmptz->getOffset(time + kDstCheckRange, FALSE, raw, sav, status); |
| if (sav != 0){ |
| useStandard = FALSE; |
| } |
| } |
| if (U_FAILURE(status)) { |
| delete tmptz; |
| result.remove(); |
| return result; |
| } |
| } |
| delete tmptz; |
| } |
| if (useStandard) { |
| getString(canonicalID, (isShort ? ZSIDX_SHORT_STANDARD : ZSIDX_LONG_STANDARD), |
| time, commonlyUsedOnly, result); |
| |
| // Note: |
| // In CLDR 1.5.1, a same localization is used for both generic and standard |
| // for some metazones in some locales. This is actually data bugs and should |
| // be resolved in later versions of CLDR. For now, we check if the standard |
| // name is different from its generic name below. |
| if (!result.isEmpty()) { |
| UnicodeString genericNonLocation; |
| getString(canonicalID, (isShort ? ZSIDX_SHORT_GENERIC : ZSIDX_LONG_GENERIC), |
| time, commonlyUsedOnly, genericNonLocation); |
| if (!genericNonLocation.isEmpty() && result == genericNonLocation) { |
| result.remove(); |
| } |
| } |
| } |
| if (result.isEmpty()) { |
| ZoneStrings *mzstrings = (ZoneStrings*)uhash_get(fMzidToStrings, mzid.getTerminatedBuffer()); |
| if (mzstrings != NULL) { |
| if (isShort) { |
| if (!commonlyUsedOnly || mzstrings->isShortFormatCommonlyUsed()) { |
| mzstrings->getString(ZSIDX_SHORT_GENERIC, result); |
| } |
| } else { |
| mzstrings->getString(ZSIDX_LONG_GENERIC, result); |
| } |
| } |
| if (!result.isEmpty()) { |
| // Check if the offsets at the given time matches the preferred zone's offsets |
| UnicodeString preferredId; |
| UnicodeString region; |
| ZoneMeta::getZoneIdByMetazone(mzid, getRegion(region), preferredId); |
| if (canonicalID != preferredId) { |
| // Check if the offsets at the given time are identical with the preferred zone |
| raw = cal.get(UCAL_ZONE_OFFSET, status); |
| if (U_FAILURE(status)) { |
| result.remove(); |
| return result; |
| } |
| TimeZone *preferredZone = TimeZone::createTimeZone(preferredId); |
| int32_t prfRaw, prfSav; |
| // Check offset in preferred time zone with wall time. |
| // With getOffset(time, false, preferredOffsets), |
| // you may get incorrect results because of time overlap at DST->STD |
| // transition. |
| preferredZone->getOffset(time + raw + sav, TRUE, prfRaw, prfSav, status); |
| delete preferredZone; |
| |
| if (U_FAILURE(status)) { |
| result.remove(); |
| return result; |
| } |
| if ((raw != prfRaw || sav != prfSav) && zstrings != NULL) { |
| // Use generic partial location string as fallback |
| zstrings->getGenericPartialLocationString(mzid, isShort, commonlyUsedOnly, result); |
| } |
| } |
| } |
| } |
| } |
| } |
| if (result.isEmpty()) { |
| // Use location format as the final fallback |
| getString(canonicalID, ZSIDX_LOCATION, time, FALSE /*not used*/, result); |
| } |
| |
| return result; |
| } |
| |
| UnicodeString& |
| ZoneStringFormat::getGenericPartialLocationString(const UnicodeString &tzid, UBool isShort, |
| UDate date, UBool commonlyUsedOnly, UnicodeString &result) const { |
| UErrorCode status = U_ZERO_ERROR; |
| result.remove(); |
| if (!fIsFullyLoaded) { |
| // Lazy loading |
| ZoneStringFormat *nonConstThis = const_cast<ZoneStringFormat *>(this); |
| nonConstThis->loadZone(tzid, status); |
| } |
| |
| if (uhash_count(fTzidToStrings) <= 0) { |
| return result; |
| } |
| |
| UnicodeString canonicalID; |
| TimeZone::getCanonicalID(tzid, canonicalID, status); |
| if (U_FAILURE(status)) { |
| // Unknown ID, so no corresponding meta data. |
| return result; |
| } |
| |
| UnicodeString mzid; |
| ZoneMeta::getMetazoneID(canonicalID, date, mzid); |
| |
| if (!mzid.isEmpty()) { |
| ZoneStrings *zstrings = (ZoneStrings*)uhash_get(fTzidToStrings, canonicalID.getTerminatedBuffer()); |
| if (zstrings != NULL) { |
| zstrings->getGenericPartialLocationString(mzid, isShort, commonlyUsedOnly, result); |
| } |
| } |
| return result; |
| } |
| |
| // This method does lazy zone string loading |
| const ZoneStringInfo* |
| ZoneStringFormat::find(const UnicodeString &text, int32_t start, int32_t types, |
| int32_t &matchLength, UErrorCode &status) const { |
| |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| |
| const ZoneStringInfo * result = subFind(text, start, types, matchLength, status); |
| if (fIsFullyLoaded) { |
| return result; |
| } |
| // When zone string data is partially loaded, |
| // this method return the result only when |
| // the input text is fully consumed. |
| if (result != NULL) { |
| UnicodeString tmpString; |
| matchLength = (result->getString(tmpString)).length(); |
| if (text.length() - start == matchLength) { |
| return result; |
| } |
| } |
| |
| // Now load all zone strings |
| ZoneStringFormat *nonConstThis = const_cast<ZoneStringFormat *>(this); |
| nonConstThis->loadFull(status); |
| |
| return subFind(text, start, types, matchLength, status); |
| } |
| |
| |
| /* |
| * Find a prefix matching time zone for the given zone string types. |
| * @param text The text contains a time zone string |
| * @param start The start index within the text |
| * @param types The bit mask representing a set of requested types |
| * @return If any zone string matched for the requested types, returns a |
| * ZoneStringInfo for the longest match. If no matches are found for |
| * the requested types, returns a ZoneStringInfo for the longest match |
| * for any other types. If nothing matches at all, returns null. |
| */ |
| const ZoneStringInfo* |
| ZoneStringFormat::subFind(const UnicodeString &text, int32_t start, int32_t types, |
| int32_t &matchLength, UErrorCode &status) const { |
| matchLength = 0; |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| if (fZoneStringsTrie.isEmpty()) { |
| return NULL; |
| } |
| |
| const ZoneStringInfo *result = NULL; |
| const ZoneStringInfo *fallback = NULL; |
| int32_t fallbackMatchLen = 0; |
| |
| ZoneStringSearchResultHandler handler(status); |
| fZoneStringsTrie.search(text, start, (TextTrieMapSearchResultHandler*)&handler, status); |
| if (U_SUCCESS(status)) { |
| int32_t numMatches = handler.countMatches(); |
| for (int32_t i = 0; i < numMatches; i++) { |
| int32_t tmpMatchLen = 0; // init. output only param to silence gcc |
| const ZoneStringInfo *tmp = handler.getMatch(i, tmpMatchLen); |
| if ((types & tmp->fType) != 0) { |
| if (result == NULL || matchLength < tmpMatchLen) { |
| result = tmp; |
| matchLength = tmpMatchLen; |
| } else if (matchLength == tmpMatchLen) { |
| // Tie breaker - there are some examples that a |
| // long standard name is identical with a location |
| // name - for example, "Uruguay Time". In this case, |
| // we interpret it as generic, not specific. |
| if (tmp->isGeneric() && !result->isGeneric()) { |
| result = tmp; |
| } |
| } |
| } else if (result == NULL) { |
| if (fallback == NULL || fallbackMatchLen < tmpMatchLen) { |
| fallback = tmp; |
| fallbackMatchLen = tmpMatchLen; |
| } else if (fallbackMatchLen == tmpMatchLen) { |
| if (tmp->isGeneric() && !fallback->isGeneric()) { |
| fallback = tmp; |
| } |
| } |
| } |
| } |
| if (result == NULL && fallback != NULL) { |
| result = fallback; |
| matchLength = fallbackMatchLen; |
| } |
| } |
| return result; |
| } |
| |
| |
| UnicodeString& |
| ZoneStringFormat::getRegion(UnicodeString ®ion) const { |
| const char* country = fLocale.getCountry(); |
| // TODO: Utilize addLikelySubtag in Locale to resolve default region |
| // when the implementation is ready. |
| region.setTo(UnicodeString(country, -1, US_INV)); |
| return region; |
| } |
| |
| MessageFormat* |
| ZoneStringFormat::getFallbackFormat(const Locale &locale, UErrorCode &status) { |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| UnicodeString pattern(TRUE, gDefFallbackPattern, -1); |
| UResourceBundle *zoneStringsArray = ures_open(U_ICUDATA_ZONE, locale.getName(), &status); |
| zoneStringsArray = ures_getByKeyWithFallback(zoneStringsArray, gZoneStringsTag, zoneStringsArray, &status); |
| int32_t len; |
| const UChar *flbkfmt = ures_getStringByKeyWithFallback(zoneStringsArray, gFallbackFormatTag, &len, &status); |
| if (U_SUCCESS(status)) { |
| pattern.setTo(flbkfmt); |
| } else { |
| status = U_ZERO_ERROR; |
| } |
| ures_close(zoneStringsArray); |
| |
| MessageFormat *fallbackFmt = new MessageFormat(pattern, status); |
| return fallbackFmt; |
| } |
| |
| MessageFormat* |
| ZoneStringFormat::getRegionFormat(const Locale& locale, UErrorCode &status) { |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| UnicodeString pattern(TRUE, gDefRegionPattern, -1); |
| UResourceBundle *zoneStringsArray = ures_open(U_ICUDATA_ZONE, locale.getName(), &status); |
| zoneStringsArray = ures_getByKeyWithFallback(zoneStringsArray, gZoneStringsTag, zoneStringsArray, &status); |
| int32_t len; |
| const UChar *regionfmt = ures_getStringByKeyWithFallback(zoneStringsArray, gRegionFormatTag, &len, &status); |
| if (U_SUCCESS(status)) { |
| pattern.setTo(regionfmt); |
| } else { |
| status = U_ZERO_ERROR; |
| } |
| ures_close(zoneStringsArray); |
| |
| MessageFormat *regionFmt = new MessageFormat(pattern, status); |
| return regionFmt; |
| } |
| |
| const UChar* |
| ZoneStringFormat::getZoneStringFromBundle(const UResourceBundle *zoneitem, const char *key) { |
| const UChar *str = NULL; |
| if (zoneitem != NULL) { |
| UErrorCode status = U_ZERO_ERROR; |
| int32_t len; |
| str = ures_getStringByKeyWithFallback(zoneitem, key, &len, &status); |
| str = fStringPool.adopt(str, status); |
| if (U_FAILURE(status)) { |
| str = NULL; |
| } |
| } |
| return str; |
| } |
| |
| UBool |
| ZoneStringFormat::isCommonlyUsed(const UResourceBundle *zoneitem) { |
| if (zoneitem == NULL) { |
| return TRUE; |
| } |
| |
| UBool commonlyUsed = FALSE; |
| UErrorCode status = U_ZERO_ERROR; |
| UResourceBundle *cuRes = ures_getByKey(zoneitem, gCommonlyUsedTag, NULL, &status); |
| int32_t cuValue = ures_getInt(cuRes, &status); |
| if (U_SUCCESS(status)) { |
| if (cuValue == 1) { |
| commonlyUsed = TRUE; |
| } |
| } |
| ures_close(cuRes); |
| return commonlyUsed; |
| } |
| |
| UnicodeString& |
| ZoneStringFormat::getLocalizedCountry(const UnicodeString &countryCode, const Locale &locale, UnicodeString &displayCountry) { |
| // We do not want to use display country names only from the target language bundle |
| // Note: we should do this in better way. |
| displayCountry.remove(); |
| int32_t ccLen = countryCode.length(); |
| if (ccLen > 0 && ccLen < ULOC_COUNTRY_CAPACITY) { |
| UErrorCode status = U_ZERO_ERROR; |
| UResourceBundle *localeBundle = ures_open(NULL, locale.getName(), &status); |
| if (U_SUCCESS(status)) { |
| const char *bundleLocStr = ures_getLocale(localeBundle, &status); |
| if (U_SUCCESS(status) && uprv_strlen(bundleLocStr) > 0) { |
| Locale bundleLoc(bundleLocStr); |
| if (uprv_strcmp(bundleLocStr, "root") != 0 && |
| uprv_strcmp(bundleLoc.getLanguage(), locale.getLanguage()) == 0) { |
| // Create a fake locale strings |
| char tmpLocStr[ULOC_COUNTRY_CAPACITY + 3]; |
| uprv_strcpy(tmpLocStr, "xx_"); |
| u_UCharsToChars(countryCode.getBuffer(), &tmpLocStr[3], ccLen); |
| tmpLocStr[3 + ccLen] = 0; |
| |
| Locale tmpLoc(tmpLocStr); |
| tmpLoc.getDisplayCountry(locale, displayCountry); |
| } |
| } |
| } |
| ures_close(localeBundle); |
| } |
| if (displayCountry.isEmpty()) { |
| // Use the country code as the fallback |
| displayCountry.setTo(countryCode); |
| } |
| return displayCountry; |
| } |
| |
| // ---------------------------------------------------------------------------- |
| /* |
| * ZoneStrings constructor adopts (and promptly copies and deletes) |
| * the input UnicodeString arrays. |
| */ |
| ZoneStrings::ZoneStrings(UnicodeString *strings, |
| int32_t stringsCount, |
| UBool commonlyUsed, |
| UnicodeString **genericPartialLocationStrings, |
| int32_t genericRowCount, |
| int32_t genericColCount, |
| ZSFStringPool &sp, |
| UErrorCode &status) |
| : fStrings(NULL), |
| fStringsCount(stringsCount), |
| fIsCommonlyUsed(commonlyUsed), |
| fGenericPartialLocationStrings(NULL), |
| fGenericPartialLocationRowCount(genericRowCount), |
| fGenericPartialLocationColCount(genericColCount) |
| { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| int32_t i, j; |
| if (strings != NULL) { |
| fStrings = (const UChar **)uprv_malloc(sizeof(const UChar **) * stringsCount); |
| if (fStrings == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| for (i=0; i<fStringsCount; i++) { |
| fStrings[i] = sp.get(strings[i], status); |
| } |
| delete[] strings; |
| } |
| if (genericPartialLocationStrings != NULL) { |
| fGenericPartialLocationStrings = |
| (const UChar ***)uprv_malloc(sizeof(const UChar ***) * genericRowCount); |
| if (fGenericPartialLocationStrings == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| for (i=0; i < fGenericPartialLocationRowCount; i++) { |
| fGenericPartialLocationStrings[i] = |
| (const UChar **)uprv_malloc(sizeof(const UChar **) * genericColCount); |
| if (fGenericPartialLocationStrings[i] == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| continue; // Continue so that fGenericPartialLocationStrings will not contain uninitialized junk, |
| } // which would crash the destructor. |
| for (j=0; j<genericColCount; j++) { |
| fGenericPartialLocationStrings[i][j] = |
| sp.get(genericPartialLocationStrings[i][j], status); |
| } |
| delete[] genericPartialLocationStrings[i]; |
| } |
| uprv_free(genericPartialLocationStrings); |
| } |
| } |
| |
| ZoneStrings::~ZoneStrings() { |
| uprv_free(fStrings); |
| if (fGenericPartialLocationStrings != NULL) { |
| for (int32_t i = 0; i < fGenericPartialLocationRowCount; i++) { |
| uprv_free(fGenericPartialLocationStrings[i]); |
| } |
| uprv_free(fGenericPartialLocationStrings); |
| } |
| } |
| |
| |
| UnicodeString& |
| ZoneStrings::getString(int32_t typeIdx, UnicodeString &result) const { |
| if (typeIdx >= 0 && typeIdx < fStringsCount) { |
| result.setTo(fStrings[typeIdx], -1); |
| } else { |
| result.remove(); |
| } |
| return result; |
| } |
| |
| UnicodeString& |
| ZoneStrings::getGenericPartialLocationString(const UnicodeString &mzid, UBool isShort, |
| UBool commonlyUsedOnly, UnicodeString &result) const { |
| UBool isSet = FALSE; |
| if (fGenericPartialLocationColCount >= 2) { |
| for (int32_t i = 0; i < fGenericPartialLocationRowCount; i++) { |
| if (mzid.compare(fGenericPartialLocationStrings[i][0], -1) == 0) { |
| if (isShort) { |
| if (fGenericPartialLocationColCount >= 3) { |
| if (!commonlyUsedOnly || |
| fGenericPartialLocationColCount == 3 || |
| fGenericPartialLocationStrings[i][3][0] != 0) { |
| result.setTo(fGenericPartialLocationStrings[i][2], -1); |
| isSet = TRUE; |
| } |
| } |
| } else { |
| result.setTo(fGenericPartialLocationStrings[i][1], -1); |
| isSet = TRUE; |
| } |
| break; |
| } |
| } |
| } |
| if (!isSet) { |
| result.remove(); |
| } |
| return result; |
| } |
| |
| // -------------------------------------------------------------- |
| SafeZoneStringFormatPtr::SafeZoneStringFormatPtr(ZSFCacheEntry *cacheEntry) |
| : fCacheEntry(cacheEntry) { |
| } |
| |
| SafeZoneStringFormatPtr::~SafeZoneStringFormatPtr() { |
| fCacheEntry->delRef(); |
| } |
| |
| const ZoneStringFormat* |
| SafeZoneStringFormatPtr::get() const { |
| return fCacheEntry->getZoneStringFormat(); |
| } |
| |
| ZSFCacheEntry::ZSFCacheEntry(const Locale &locale, ZoneStringFormat *zsf, ZSFCacheEntry *next) |
| : fLocale(locale), fZoneStringFormat(zsf), |
| fNext(next), fRefCount(1) |
| { |
| } |
| |
| ZSFCacheEntry::~ZSFCacheEntry () { |
| delete fZoneStringFormat; |
| } |
| |
| const ZoneStringFormat* |
| ZSFCacheEntry::getZoneStringFormat(void) { |
| return (const ZoneStringFormat*)fZoneStringFormat; |
| } |
| |
| void |
| ZSFCacheEntry::delRef(void) { |
| umtx_lock(&gZSFCacheLock); |
| --fRefCount; |
| umtx_unlock(&gZSFCacheLock); |
| } |
| |
| ZSFCache::ZSFCache(int32_t capacity) |
| : fCapacity(capacity), fFirst(NULL) { |
| } |
| |
| ZSFCache::~ZSFCache() { |
| ZSFCacheEntry *entry = fFirst; |
| while (entry) { |
| ZSFCacheEntry *next = entry->fNext; |
| delete entry; |
| entry = next; |
| } |
| } |
| |
| SafeZoneStringFormatPtr* |
| ZSFCache::get(const Locale &locale, UErrorCode &status) { |
| SafeZoneStringFormatPtr *result = NULL; |
| |
| // Search the cache entry list |
| ZSFCacheEntry *entry = NULL; |
| ZSFCacheEntry *next, *prev; |
| |
| umtx_lock(&gZSFCacheLock); |
| entry = fFirst; |
| prev = NULL; |
| while (entry) { |
| next = entry->fNext; |
| if (entry->fLocale == locale) { |
| // Add reference count |
| entry->fRefCount++; |
| |
| // move the entry to the top |
| if (entry != fFirst) { |
| prev->fNext = next; |
| entry->fNext = fFirst; |
| fFirst = entry; |
| } |
| break; |
| } |
| prev = entry; |
| entry = next; |
| } |
| umtx_unlock(&gZSFCacheLock); |
| |
| // Create a new ZoneStringFormat |
| if (entry == NULL) { |
| ZoneStringFormat *zsf = new ZoneStringFormat(locale, status); |
| if (U_FAILURE(status)) { |
| delete zsf; |
| return NULL; |
| } |
| if (zsf == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| |
| // Now add the new entry |
| umtx_lock(&gZSFCacheLock); |
| // Make sure no other threads already created the one for the same locale |
| entry = fFirst; |
| prev = NULL; |
| while (entry) { |
| next = entry->fNext; |
| if (entry->fLocale == locale) { |
| // Add reference count |
| entry->fRefCount++; |
| |
| // move the entry to the top |
| if (entry != fFirst) { |
| prev->fNext = next; |
| entry->fNext = fFirst; |
| fFirst = entry; |
| } |
| break; |
| } |
| prev = entry; |
| entry = next; |
| } |
| if (entry == NULL) { |
| // Add the new one to the top |
| next = fFirst; |
| entry = new ZSFCacheEntry(locale, zsf, next); |
| fFirst = entry; |
| } else { |
| delete zsf; |
| } |
| umtx_unlock(&gZSFCacheLock); |
| } |
| |
| result = new SafeZoneStringFormatPtr(entry); |
| |
| // Now, delete unused cache entries beyond the capacity |
| umtx_lock(&gZSFCacheLock); |
| entry = fFirst; |
| prev = NULL; |
| int32_t idx = 1; |
| while (entry) { |
| next = entry->fNext; |
| if (idx >= fCapacity && entry->fRefCount == 0) { |
| if (entry == fFirst) { |
| fFirst = next; |
| } else { |
| prev->fNext = next; |
| } |
| delete entry; |
| } else { |
| prev = entry; |
| } |
| entry = next; |
| idx++; |
| } |
| umtx_unlock(&gZSFCacheLock); |
| |
| return result; |
| } |
| |
| |
| /* |
| * Zone String Formatter String Pool Implementation |
| * |
| * String pool for (UChar *) strings. Avoids having repeated copies of the same string. |
| */ |
| |
| static const int32_t POOL_CHUNK_SIZE = 2000; |
| struct ZSFStringPoolChunk: public UMemory { |
| ZSFStringPoolChunk *fNext; // Ptr to next pool chunk |
| int32_t fLimit; // Index to start of unused area at end of fStrings |
| UChar fStrings[POOL_CHUNK_SIZE]; // Strings array |
| ZSFStringPoolChunk(); |
| }; |
| |
| ZSFStringPoolChunk::ZSFStringPoolChunk() { |
| fNext = NULL; |
| fLimit = 0; |
| } |
| |
| ZSFStringPool::ZSFStringPool(UErrorCode &status) { |
| fChunks = NULL; |
| fHash = NULL; |
| if (U_FAILURE(status)) { |
| return; |
| } |
| fChunks = new ZSFStringPoolChunk; |
| if (fChunks == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| |
| fHash = uhash_open(uhash_hashUChars /* keyHash */, |
| uhash_compareUChars /* keyComp */, |
| uhash_compareUChars /* valueComp */, |
| &status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| } |
| |
| |
| ZSFStringPool::~ZSFStringPool() { |
| if (fHash != NULL) { |
| uhash_close(fHash); |
| fHash = NULL; |
| } |
| |
| while (fChunks != NULL) { |
| ZSFStringPoolChunk *nextChunk = fChunks->fNext; |
| delete fChunks; |
| fChunks = nextChunk; |
| } |
| } |
| |
| static const UChar EmptyString = 0; |
| |
| const UChar *ZSFStringPool::get(const UChar *s, UErrorCode &status) { |
| const UChar *pooledString; |
| if (U_FAILURE(status)) { |
| return &EmptyString; |
| } |
| |
| pooledString = static_cast<UChar *>(uhash_get(fHash, s)); |
| if (pooledString != NULL) { |
| return pooledString; |
| } |
| |
| int32_t length = u_strlen(s); |
| int32_t remainingLength = POOL_CHUNK_SIZE - fChunks->fLimit; |
| if (remainingLength <= length) { |
| U_ASSERT(length < POOL_CHUNK_SIZE); |
| if (length >= POOL_CHUNK_SIZE) { |
| status = U_INTERNAL_PROGRAM_ERROR; |
| return &EmptyString; |
| } |
| ZSFStringPoolChunk *oldChunk = fChunks; |
| fChunks = new ZSFStringPoolChunk; |
| if (fChunks == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return &EmptyString; |
| } |
| fChunks->fNext = oldChunk; |
| } |
| |
| UChar *destString = &fChunks->fStrings[fChunks->fLimit]; |
| u_strcpy(destString, s); |
| fChunks->fLimit += (length + 1); |
| uhash_put(fHash, destString, destString, &status); |
| return destString; |
| } |
| |
| |
| // |
| // ZSFStringPool::adopt() Put a string into the hash, but do not copy the string data |
| // into the pool's storage. Used for strings from resource bundles, |
| // which will perisist for the life of the zone string formatter, and |
| // therefore can be used directly without copying. |
| const UChar *ZSFStringPool::adopt(const UChar * s, UErrorCode &status) { |
| const UChar *pooledString; |
| if (U_FAILURE(status)) { |
| return &EmptyString; |
| } |
| if (s != NULL) { |
| pooledString = static_cast<UChar *>(uhash_get(fHash, s)); |
| if (pooledString == NULL) { |
| UChar *ncs = const_cast<UChar *>(s); |
| uhash_put(fHash, ncs, ncs, &status); |
| } |
| } |
| return s; |
| } |
| |
| |
| const UChar *ZSFStringPool::get(const UnicodeString &s, UErrorCode &status) { |
| UnicodeString &nonConstStr = const_cast<UnicodeString &>(s); |
| return this->get(nonConstStr.getTerminatedBuffer(), status); |
| } |
| |
| /* |
| * freeze(). Close the hash table that maps to the pooled strings. |
| * After freezing, the pool can not be searched or added to, |
| * but all existing references to pooled strings remain valid. |
| * |
| * The main purpose is to recover the storage used for the hash. |
| */ |
| void ZSFStringPool::freeze() { |
| uhash_close(fHash); |
| fHash = NULL; |
| } |
| |
| U_NAMESPACE_END |
| |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |
