icuSources/i18n/zstrfmt.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2007-2010, International Business Machines Corporation and    *
   4 * others. All Rights Reserved.                                                *
   5 *******************************************************************************
   6 */
   7
   8 #include "unicode/utypes.h"
   9
  10 #if !UCONFIG_NO_FORMATTING
  11
  12 #include "zstrfmt.h"
  13
  14 #include "unicode/ustring.h"
  15 #include "unicode/putil.h"
  16 #include "unicode/msgfmt.h"
  17 #include "unicode/basictz.h"
  18 #include "unicode/simpletz.h"
  19 #include "unicode/rbtz.h"
  20 #include "unicode/vtzone.h"
  21
  22 #include "uvector.h"
  23 #include "cstring.h"
  24 #include "cmemory.h"
  25 #include "uresimp.h"
  26 #include "zonemeta.h"
  27 #include "olsontz.h"
  28 #include "umutex.h"
  29 #include "ucln_in.h"
  30 #include "uassert.h"
  31 #include "ureslocs.h"
  32
  33 /**
  34  * global ZoneStringFormatCache stuffs
  35  */
  36 static UMTX gZSFCacheLock = NULL;
  37 static U_NAMESPACE_QUALIFIER ZSFCache *gZoneStringFormatCache = NULL;
  38
  39 U_CDECL_BEGIN
  40 /**
  41  * ZoneStringFormatCache cleanup callback func
  42  */
  43 static UBool U_CALLCONV zoneStringFormat_cleanup(void)
  44 {
  45     umtx_destroy(&gZSFCacheLock);
  46     if (gZoneStringFormatCache != NULL) {
  47         delete gZoneStringFormatCache;
  48         gZoneStringFormatCache = NULL;
  49     }
  50     gZoneStringFormatCache = NULL;
  51     return TRUE;
  52 }
  53
  54 /**
  55  * Deleter for ZoneStringInfo
  56  */
  57 static void U_CALLCONV
  58 deleteZoneStringInfo(void *obj) {
  59     delete (U_NAMESPACE_QUALIFIER ZoneStringInfo*)obj;
  60 }
  61
  62 /**
  63  * Deleter for ZoneStrings
  64  */
  65 static void U_CALLCONV
  66 deleteZoneStrings(void *obj) {
  67     delete (U_NAMESPACE_QUALIFIER ZoneStrings*)obj;
  68 }
  69 U_CDECL_END
  70
  71 U_NAMESPACE_BEGIN
  72
  73 #define ZID_KEY_MAX 128
  74
  75 static const char gCountriesTag[]       = "Countries";
  76 static const char gZoneStringsTag[]     = "zoneStrings";
  77 static const char gShortGenericTag[]    = "sg";
  78 static const char gShortStandardTag[]   = "ss";
  79 static const char gShortDaylightTag[]   = "sd";
  80 static const char gLongGenericTag[]     = "lg";
  81 static const char gLongStandardTag[]    = "ls";
  82 static const char gLongDaylightTag[]    = "ld";
  83 static const char gExemplarCityTag[]    = "ec";
  84 static const char gCommonlyUsedTag[]    = "cu";
  85 static const char gFallbackFormatTag[]  = "fallbackFormat";
  86 static const char gRegionFormatTag[]    = "regionFormat";
  87
  88 #define MZID_PREFIX_LEN 5
  89 static const char gMetazoneIdPrefix[]   = "meta:";
  90
  91 #define MAX_METAZONES_PER_ZONE 10
  92
  93 static const UChar gDefFallbackPattern[]    = {0x7B, 0x31, 0x7D, 0x20, 0x28, 0x7B, 0x30, 0x7D, 0x29, 0x00}; // "{1} ({0})"
  94 static const UChar gDefRegionPattern[]      = {0x7B, 0x30, 0x7D, 0x00}; // "{0}"
  95 static const UChar gCommonlyUsedTrue[]      = {0x31, 0x00}; // "1"
  96
  97 static const double kDstCheckRange      = (double)184*U_MILLIS_PER_DAY;
  98
  99 static int32_t
 100 getTimeZoneTranslationTypeIndex(TimeZoneTranslationType type) {
 101     int32_t typeIdx = 0;
 102     switch (type) {
 103         case LOCATION:
 104             typeIdx = ZSIDX_LOCATION;
 105             break;
 106         case GENERIC_LONG:
 107             typeIdx = ZSIDX_LONG_GENERIC;
 108             break;
 109         case GENERIC_SHORT:
 110             typeIdx = ZSIDX_SHORT_GENERIC;
 111             break;
 112         case STANDARD_LONG:
 113             typeIdx = ZSIDX_LONG_STANDARD;
 114             break;
 115         case STANDARD_SHORT:
 116             typeIdx = ZSIDX_SHORT_STANDARD;
 117             break;
 118         case DAYLIGHT_LONG:
 119             typeIdx = ZSIDX_LONG_DAYLIGHT;
 120             break;
 121         case DAYLIGHT_SHORT:
 122             typeIdx = ZSIDX_SHORT_DAYLIGHT;
 123             break;
 124     }
 125     return typeIdx;
 126 }
 127
 128 static int32_t
 129 getTimeZoneTranslationType(TimeZoneTranslationTypeIndex typeIdx) {
 130     int32_t type = 0;
 131     switch (typeIdx) {
 132         case ZSIDX_LOCATION:
 133             type = LOCATION;
 134             break;
 135         case ZSIDX_LONG_GENERIC:
 136             type = GENERIC_LONG;
 137             break;
 138         case ZSIDX_SHORT_GENERIC:
 139             type = GENERIC_SHORT;
 140             break;
 141         case ZSIDX_LONG_STANDARD:
 142             type = STANDARD_LONG;
 143             break;
 144         case ZSIDX_SHORT_STANDARD:
 145             type = STANDARD_SHORT;
 146             break;
 147         case ZSIDX_LONG_DAYLIGHT:
 148             type = DAYLIGHT_LONG;
 149             break;
 150         case ZSIDX_COUNT:
 151         case ZSIDX_SHORT_DAYLIGHT:
 152             type = DAYLIGHT_SHORT;
 153             break;
 154         default:
 155             break;
 156     }
 157     return type;
 158 }
 159
 160 #define DEFAULT_CHARACTERNODE_CAPACITY 1
 161
 162 // ----------------------------------------------------------------------------
 163 void CharacterNode::clear() {
 164     uprv_memset(this, 0, sizeof(*this));
 165 }
 166
 167 void CharacterNode::deleteValues() {
 168     if (fValues == NULL) {
 169         // Do nothing.
 170     } else if (!fHasValuesVector) {
 171         deleteZoneStringInfo(fValues);
 172     } else {
 173         delete (UVector *)fValues;
 174     }
 175 }
 176
 177 void
 178 CharacterNode::addValue(void *value, UErrorCode &status) {
 179     if (U_FAILURE(status)) {
 180         deleteZoneStringInfo(value);
 181         return;
 182     }
 183     if (fValues == NULL) {
 184         fValues = value;
 185     } else {
 186         // At least one value already.
 187         if (!fHasValuesVector) {
 188             // There is only one value so far, and not in a vector yet.
 189             // Create a vector and add the old value.
 190             UVector *values = new UVector(deleteZoneStringInfo, NULL, DEFAULT_CHARACTERNODE_CAPACITY, status);
 191             if (U_FAILURE(status)) {
 192                 deleteZoneStringInfo(value);
 193                 return;
 194             }
 195             values->addElement(fValues, status);
 196             fValues = values;
 197             fHasValuesVector = TRUE;
 198         }
 199         // Add the new value.
 200         ((UVector *)fValues)->addElement(value, status);
 201     }
 202 }
 203
 204 //----------------------------------------------------------------------------
 205 // Virtual destructor to avoid warning
 206 TextTrieMapSearchResultHandler::~TextTrieMapSearchResultHandler(){
 207 }
 208
 209 // ----------------------------------------------------------------------------
 210 TextTrieMap::TextTrieMap(UBool ignoreCase)
 211 : fIgnoreCase(ignoreCase), fNodes(NULL), fNodesCapacity(0), fNodesCount(0),
 212   fLazyContents(NULL), fIsEmpty(TRUE) {
 213 }
 214
 215 TextTrieMap::~TextTrieMap() {
 216     int32_t index;
 217     for (index = 0; index < fNodesCount; ++index) {
 218         fNodes[index].deleteValues();
 219     }
 220     uprv_free(fNodes);
 221     if (fLazyContents != NULL) {
 222         for (int32_t i=0; i<fLazyContents->size(); i+=2) {
 223             ZoneStringInfo *zsinf = (ZoneStringInfo *)fLazyContents->elementAt(i+1);
 224             delete zsinf;
 225         }
 226         delete fLazyContents;
 227     }
 228 }
 229
 230 int32_t TextTrieMap::isEmpty() const {
 231     // Use a separate field for fIsEmpty because it will remain unchanged once the
 232     //   Trie is built, while fNodes and fLazyContents change with the lazy init
 233     //   of the nodes structure.  Trying to test the changing fields has
 234     //   thread safety complications.
 235     return fIsEmpty;
 236 }
 237
 238
 239 //  We defer actually building the TextTrieMap node structure until the first time a
 240 //     search is performed.  put() simply saves the parameters in case we do
 241 //     eventually need to build it.
 242 //
 243 void
 244 TextTrieMap::put(const UnicodeString &key, void *value, ZSFStringPool &sp, UErrorCode &status) {
 245     fIsEmpty = FALSE;
 246     if (fLazyContents == NULL) {
 247         fLazyContents = new UVector(status);
 248         if (fLazyContents == NULL) {
 249             status = U_MEMORY_ALLOCATION_ERROR;
 250         }
 251     }
 252     if (U_FAILURE(status)) {
 253         return;
 254     }
 255     UChar *s = const_cast<UChar *>(sp.get(key, status));
 256     fLazyContents->addElement(s, status);
 257     fLazyContents->addElement(value, status);
 258 }
 259
 260
 261 void
 262 TextTrieMap::putImpl(const UnicodeString &key, void *value, UErrorCode &status) {
 263     if (fNodes == NULL) {
 264         fNodesCapacity = 512;
 265         fNodes = (CharacterNode *)uprv_malloc(fNodesCapacity * sizeof(CharacterNode));
 266         fNodes[0].clear();  // Init root node.
 267         fNodesCount = 1;
 268     }
 269
 270     UnicodeString foldedKey;
 271     const UChar *keyBuffer;
 272     int32_t keyLength;
 273     if (fIgnoreCase) {
 274         // Ok to use fastCopyFrom() because we discard the copy when we return.
 275         foldedKey.fastCopyFrom(key).foldCase();
 276         keyBuffer = foldedKey.getBuffer();
 277         keyLength = foldedKey.length();
 278     } else {
 279         keyBuffer = key.getBuffer();
 280         keyLength = key.length();
 281     }
 282
 283     CharacterNode *node = fNodes;
 284     int32_t index;
 285     for (index = 0; index < keyLength; ++index) {
 286         node = addChildNode(node, keyBuffer[index], status);
 287     }
 288     node->addValue(value, status);
 289 }
 290
 291 UBool
 292 TextTrieMap::growNodes() {
 293     if (fNodesCapacity == 0xffff) {
 294         return FALSE;  // We use 16-bit node indexes.
 295     }
 296     int32_t newCapacity = fNodesCapacity + 1000;
 297     if (newCapacity > 0xffff) {
 298         newCapacity = 0xffff;
 299     }
 300     CharacterNode *newNodes = (CharacterNode *)uprv_malloc(newCapacity * sizeof(CharacterNode));
 301     if (newNodes == NULL) {
 302         return FALSE;
 303     }
 304     uprv_memcpy(newNodes, fNodes, fNodesCount * sizeof(CharacterNode));
 305     uprv_free(fNodes);
 306     fNodes = newNodes;
 307     fNodesCapacity = newCapacity;
 308     return TRUE;
 309 }
 310
 311 CharacterNode*
 312 TextTrieMap::addChildNode(CharacterNode *parent, UChar c, UErrorCode &status) {
 313     if (U_FAILURE(status)) {
 314         return NULL;
 315     }
 316     // Linear search of the sorted list of children.
 317     uint16_t prevIndex = 0;
 318     uint16_t nodeIndex = parent->fFirstChild;
 319     while (nodeIndex > 0) {
 320         CharacterNode *current = fNodes + nodeIndex;
 321         UChar childCharacter = current->fCharacter;
 322         if (childCharacter == c) {
 323             return current;
 324         } else if (childCharacter > c) {
 325             break;
 326         }
 327         prevIndex = nodeIndex;
 328         nodeIndex = current->fNextSibling;
 329     }
 330
 331     // Ensure capacity. Grow fNodes[] if needed.
 332     if (fNodesCount == fNodesCapacity) {
 333         int32_t parentIndex = (int32_t)(parent - fNodes);
 334         if (!growNodes()) {
 335             status = U_MEMORY_ALLOCATION_ERROR;
 336             return NULL;
 337         }
 338         parent = fNodes + parentIndex;
 339     }
 340
 341     // Insert a new child node with c in sorted order.
 342     CharacterNode *node = fNodes + fNodesCount;
 343     node->clear();
 344     node->fCharacter = c;
 345     node->fNextSibling = nodeIndex;
 346     if (prevIndex == 0) {
 347         parent->fFirstChild = (uint16_t)fNodesCount;
 348     } else {
 349         fNodes[prevIndex].fNextSibling = (uint16_t)fNodesCount;
 350     }
 351     ++fNodesCount;
 352     return node;
 353 }
 354
 355 CharacterNode*
 356 TextTrieMap::getChildNode(CharacterNode *parent, UChar c) const {
 357     // Linear search of the sorted list of children.
 358     uint16_t nodeIndex = parent->fFirstChild;
 359     while (nodeIndex > 0) {
 360         CharacterNode *current = fNodes + nodeIndex;
 361         UChar childCharacter = current->fCharacter;
 362         if (childCharacter == c) {
 363             return current;
 364         } else if (childCharacter > c) {
 365             break;
 366         }
 367         nodeIndex = current->fNextSibling;
 368     }
 369     return NULL;
 370 }
 371
 372 // Mutex for protecting the lazy creation of the Trie node structure on the first call to search().
 373 static UMTX TextTrieMutex;
 374
 375 // buildTrie() - The Trie node structure is needed.  Create it from the data that was
 376 //               saved at the time the ZoneStringFormatter was created.  The Trie is only
 377 //               needed for parsing operations, which are less common than formatting,
 378 //               and the Trie is big, which is why its creation is deferred until first use.
 379 void TextTrieMap::buildTrie(UErrorCode &status) {
 380     umtx_lock(&TextTrieMutex);
 381     if (fLazyContents != NULL) {
 382         for (int32_t i=0; i<fLazyContents->size(); i+=2) {
 383             const UChar *key = (UChar *)fLazyContents->elementAt(i);
 384             void  *val = fLazyContents->elementAt(i+1);
 385             UnicodeString keyString(TRUE, key, -1);  // Aliasing UnicodeString constructor.
 386             putImpl(keyString, val, status);
 387         }
 388         delete fLazyContents;
 389         fLazyContents = NULL;
 390     }
 391     umtx_unlock(&TextTrieMutex);
 392 }
 393
 394
 395 void
 396 TextTrieMap::search(const UnicodeString &text, int32_t start,
 397                   TextTrieMapSearchResultHandler *handler, UErrorCode &status) const {
 398     UBool trieNeedsInitialization = FALSE;
 399     UMTX_CHECK(&TextTrieMutex, fLazyContents != NULL, trieNeedsInitialization);
 400     if (trieNeedsInitialization) {
 401         TextTrieMap *nonConstThis = const_cast<TextTrieMap *>(this);
 402         nonConstThis->buildTrie(status);
 403     }
 404     if (fNodes == NULL) {
 405         return;
 406     }
 407     search(fNodes, text, start, start, handler, status);
 408 }
 409
 410 void
 411 TextTrieMap::search(CharacterNode *node, const UnicodeString &text, int32_t start,
 412                   int32_t index, TextTrieMapSearchResultHandler *handler, UErrorCode &status) const {
 413     if (U_FAILURE(status)) {
 414         return;
 415     }
 416     if (node->hasValues()) {
 417         if (!handler->handleMatch(index - start, node, status)) {
 418             return;
 419         }
 420         if (U_FAILURE(status)) {
 421             return;
 422         }
 423     }
 424     UChar32 c = text.char32At(index);
 425     if (fIgnoreCase) {
 426         // size of character may grow after fold operation
 427         UnicodeString tmp(c);
 428         tmp.foldCase();
 429         int32_t tmpidx = 0;
 430         while (tmpidx < tmp.length()) {
 431             c = tmp.char32At(tmpidx);
 432             node = getChildNode(node, c);
 433             if (node == NULL) {
 434                 break;
 435             }
 436             tmpidx = tmp.moveIndex32(tmpidx, 1);
 437         }
 438     } else {
 439         node = getChildNode(node, c);
 440     }
 441     if (node != NULL) {
 442         search(node, text, start, index+1, handler, status);
 443     }
 444 }
 445
 446 // ----------------------------------------------------------------------------
 447 ZoneStringInfo::ZoneStringInfo(const UnicodeString &id, const UnicodeString &str,
 448                                TimeZoneTranslationType type, ZSFStringPool &sp, UErrorCode &status)
 449 : fType(type) {
 450     fId = sp.get(id, status);
 451     fStr = sp.get(str, status);
 452 }
 453
 454 ZoneStringInfo::~ZoneStringInfo() {
 455 }
 456
 457
 458 // ----------------------------------------------------------------------------
 459 ZoneStringSearchResultHandler::ZoneStringSearchResultHandler(UErrorCode &status)
 460 : fResults(status)
 461 {
 462     clear();
 463 }
 464
 465 ZoneStringSearchResultHandler::~ZoneStringSearchResultHandler() {
 466     clear();
 467 }
 468
 469 UBool
 470 ZoneStringSearchResultHandler::handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status) {
 471     if (U_FAILURE(status)) {
 472         return FALSE;
 473     }
 474     if (node->hasValues()) {
 475         int32_t valuesCount = node->countValues();
 476         for (int32_t i = 0; i < valuesCount; i++) {
 477             ZoneStringInfo *zsinfo = (ZoneStringInfo*)node->getValue(i);
 478             if (zsinfo == NULL) {
 479                 break;
 480             }
 481             // Update the results
 482             UBool foundType = FALSE;
 483             for (int32_t j = 0; j < fResults.size(); j++) {
 484                 ZoneStringInfo *tmp = (ZoneStringInfo*)fResults.elementAt(j);
 485                 if (zsinfo->fType == tmp->fType) {
 486                     int32_t lenidx = getTimeZoneTranslationTypeIndex(tmp->fType);
 487                     if (matchLength > fMatchLen[lenidx]) {
 488                         // Same type, longer match
 489                         fResults.setElementAt(zsinfo, j);
 490                         fMatchLen[lenidx] = matchLength;
 491                     }
 492                     foundType = TRUE;
 493                     break;
 494                 }
 495             }
 496             if (!foundType) {
 497                 // not found in the current list
 498                 fResults.addElement(zsinfo, status);
 499                 fMatchLen[getTimeZoneTranslationTypeIndex(zsinfo->fType)] = matchLength;
 500             }
 501         }
 502     }
 503     return TRUE;
 504 }
 505
 506 int32_t
 507 ZoneStringSearchResultHandler::countMatches(void) {
 508     return fResults.size();
 509 }
 510
 511 const ZoneStringInfo*
 512 ZoneStringSearchResultHandler::getMatch(int32_t index, int32_t &matchLength) {
 513     ZoneStringInfo *zsinfo = NULL;
 514     if (index < fResults.size()) {
 515         zsinfo = (ZoneStringInfo*)fResults.elementAt(index);
 516         matchLength = fMatchLen[getTimeZoneTranslationTypeIndex(zsinfo->fType)];
 517     }
 518     return zsinfo;
 519 }
 520
 521 void
 522 ZoneStringSearchResultHandler::clear(void) {
 523     fResults.removeAllElements();
 524     for (int32_t i = 0; i < (int32_t)(sizeof(fMatchLen)/sizeof(fMatchLen[0])); i++) {
 525         fMatchLen[i] = 0;
 526     }
 527 }
 528
 529 // Mutex for protecting the lazy load of a zone ID (or a full load) to ZoneStringFormat structures.
 530 static UMTX ZoneStringFormatMutex;
 531
 532
 533 // ----------------------------------------------------------------------------
 534 ZoneStringFormat::ZoneStringFormat(const UnicodeString* const* strings,
 535                                    int32_t rowCount, int32_t columnCount, UErrorCode &status)
 536 : fLocale(""),
 537   fTzidToStrings(NULL),
 538   fMzidToStrings(NULL),
 539   fZoneStringsTrie(TRUE),
 540   fStringPool(status),
 541   fZoneStringsArray(NULL),
 542   fMetazoneItem(NULL),
 543   fZoneItem(NULL),
 544   fIsFullyLoaded(FALSE)
 545 {
 546     if (U_FAILURE(status)) {
 547         return;
 548     }
 549     fLocale.setToBogus();
 550     if (strings == NULL || columnCount <= 0 || rowCount <= 0) {
 551         status = U_ILLEGAL_ARGUMENT_ERROR;
 552         return;
 553     }
 554     fTzidToStrings = uhash_open(uhash_hashUChars,     // key hash function
 555                                 uhash_compareUChars,  // key comparison function
 556                                 NULL,                 // Value comparison function
 557                                 &status);
 558     fMzidToStrings = uhash_open(uhash_hashUChars,
 559                                 uhash_compareUChars,
 560                                 NULL,
 561                                 &status);
 562
 563     uhash_setValueDeleter(fTzidToStrings, deleteZoneStrings);
 564     uhash_setValueDeleter(fMzidToStrings, deleteZoneStrings);
 565
 566     for (int32_t row = 0; row < rowCount; row++) {
 567         if (strings[row][0].isEmpty()) {
 568             continue;
 569         }
 570         UnicodeString *names = new UnicodeString[ZSIDX_COUNT];
 571         for (int32_t col = 1; col < columnCount; col++) {
 572             if (!strings[row][col].isEmpty()) {
 573                 int32_t typeIdx = -1;
 574                 switch (col) {
 575                     case 1:
 576                         typeIdx = ZSIDX_LONG_STANDARD;
 577                         break;
 578                     case 2:
 579                         typeIdx = ZSIDX_SHORT_STANDARD;
 580                         break;
 581                     case 3:
 582                         typeIdx = ZSIDX_LONG_DAYLIGHT;
 583                         break;
 584                     case 4:
 585                         typeIdx = ZSIDX_SHORT_DAYLIGHT;
 586                         break;
 587                     case 5:
 588                         typeIdx = ZSIDX_LOCATION;
 589                         break;
 590                     case 6:
 591                         typeIdx = ZSIDX_LONG_GENERIC;
 592                         break;
 593                     case 7:
 594                         typeIdx = ZSIDX_SHORT_GENERIC;
 595                         break;
 596                 }
 597                 if (typeIdx != -1) {
 598                     names[typeIdx].setTo(strings[row][col]);
 599
 600                     // Put the name into the trie
 601                     int32_t type = getTimeZoneTranslationType((TimeZoneTranslationTypeIndex)typeIdx);
 602                     ZoneStringInfo *zsinf = new ZoneStringInfo(strings[row][0],
 603                                                                strings[row][col],
 604                                                                (TimeZoneTranslationType)type,
 605                                                                fStringPool,
 606                                                                status);
 607                     fZoneStringsTrie.put(strings[row][col], zsinf, fStringPool, status);
 608                     if (U_FAILURE(status)) {
 609                         delete zsinf;
 610                         goto error_cleanup;
 611                     }
 612                 }
 613             }
 614         }
 615         // Note:  ZoneStrings constructor adopts and delete the names array.
 616         ZoneStrings *zstrings = new ZoneStrings(names, ZSIDX_COUNT, TRUE, NULL, 0, 0,
 617                                                 fStringPool, status);
 618         UChar *utzid = const_cast<UChar *>(fStringPool.get(strings[row][0], status));
 619         uhash_put(fTzidToStrings, utzid, zstrings, &status);
 620         if (U_FAILURE(status)) {
 621             delete zstrings;
 622             goto error_cleanup;
 623         }
 624     }
 625     fStringPool.freeze();
 626         fIsFullyLoaded = TRUE;
 627     return;
 628
 629 error_cleanup:
 630     return;
 631 }
 632
 633 ZoneStringFormat::ZoneStringFormat(const Locale &locale, UErrorCode &status)
 634 : fLocale(locale),
 635   fTzidToStrings(NULL),
 636   fMzidToStrings(NULL),
 637   fZoneStringsTrie(TRUE),
 638   fStringPool(status),
 639   fZoneStringsArray(NULL),
 640   fMetazoneItem(NULL),
 641   fZoneItem(NULL),
 642   fIsFullyLoaded(FALSE)
 643 {
 644     if (U_FAILURE(status)) {
 645         return;
 646     }
 647     fTzidToStrings = uhash_open(uhash_hashUChars,     // key hash function
 648                                 uhash_compareUChars,  // key comparison function
 649                                 NULL,                 // Value comparison function
 650                                 &status);
 651     fMzidToStrings = uhash_open(uhash_hashUChars,     // key hash function
 652                                 uhash_compareUChars,  // key comparison function
 653                                 NULL,                 // Value comparison function
 654                                 &status);
 655     uhash_setValueDeleter(fTzidToStrings, deleteZoneStrings);
 656     uhash_setValueDeleter(fMzidToStrings, deleteZoneStrings);
 657 }
 658
 659 // Load only a single zone
 660 void
 661 ZoneStringFormat::loadZone(const UnicodeString &utzid, UErrorCode &status)
 662 {
 663         if (fIsFullyLoaded) {
 664                 return;
 665         }
 666
 667         if (U_FAILURE(status)) {
 668                 return;
 669         }
 670
 671         umtx_lock(&ZoneStringFormatMutex);
 672
 673         if (fZoneStringsArray == NULL) {
 674                 fZoneStringsArray = ures_open(U_ICUDATA_ZONE, fLocale.getName(), &status);
 675                 fZoneStringsArray = ures_getByKeyWithFallback(fZoneStringsArray, gZoneStringsTag, fZoneStringsArray, &status);
 676                 if (U_FAILURE(status)) {
 677                         // If no locale bundles are available, zoneStrings will be null.
 678                         // We still want to go through the rest of zone strings initialization,
 679                         // because generic location format is generated from tzid for the case.
 680                         // The rest of code should work even zoneStrings is null.
 681                         status = U_ZERO_ERROR;
 682                         ures_close(fZoneStringsArray);
 683                         fZoneStringsArray = NULL;
 684                 }
 685     }
 686
 687         // Skip non-canonical IDs
 688         UnicodeString canonicalID;
 689         TimeZone::getCanonicalID(utzid, canonicalID, status);
 690         if (U_FAILURE(status)) {
 691                 // Ignore unknown ID - we should not get here, but just in case.
 692                 //      status = U_ZERO_ERROR;
 693                 umtx_unlock(&ZoneStringFormatMutex);
 694                 return;
 695         }
 696
 697     if (U_SUCCESS(status)) {
 698                 if (uhash_count(fTzidToStrings) > 0) {
 699                         ZoneStrings *zstrings = (ZoneStrings*)uhash_get(fTzidToStrings, canonicalID.getTerminatedBuffer());
 700                         if (zstrings != NULL) {
 701                                 umtx_unlock(&ZoneStringFormatMutex);
 702                                 return; //      We already about this one
 703                         }
 704                 }
 705         }
 706
 707         addSingleZone(canonicalID, status);
 708
 709         umtx_unlock(&ZoneStringFormatMutex);
 710 }
 711
 712 // Load only a single zone
 713 void
 714 ZoneStringFormat::addSingleZone(UnicodeString &utzid, UErrorCode &status)
 715 {
 716         if (U_FAILURE(status)) {
 717                 return;
 718         }
 719
 720         if (uhash_count(fTzidToStrings) > 0) {
 721                 ZoneStrings *zstrings = (ZoneStrings*)uhash_get(fTzidToStrings, utzid.getTerminatedBuffer());
 722                 if (zstrings != NULL) {
 723                         return; //      We already about this one
 724                 }
 725         }
 726
 727     MessageFormat *fallbackFmt = NULL;
 728     MessageFormat *regionFmt = NULL;
 729
 730     fallbackFmt = getFallbackFormat(fLocale, status);
 731     if (U_FAILURE(status)) {
 732         goto error_cleanup;
 733     }
 734     regionFmt = getRegionFormat(fLocale, status);
 735     if (U_FAILURE(status)) {
 736         goto error_cleanup;
 737     }
 738
 739
 740         {
 741                 char zidkey[ZID_KEY_MAX+1];
 742                 char tzid[ZID_KEY_MAX+1];
 743                 utzid.extract(0, utzid.length(), zidkey, ZID_KEY_MAX, US_INV);
 744                 utzid.extract(0, utzid.length(), tzid, ZID_KEY_MAX, US_INV);
 745
 746                 const UChar *zstrarray[ZSIDX_COUNT];
 747                 const UChar *mzstrarray[ZSIDX_COUNT];
 748                 UnicodeString mzPartialLoc[MAX_METAZONES_PER_ZONE][4];
 749
 750                 // Replace '/' with ':'
 751                 char *pCity = NULL;
 752                 char *p = zidkey;
 753                 while (*p) {
 754                         if (*p == '/') {
 755                                 *p = ':';
 756                                 pCity = p + 1;
 757                         }
 758                         p++;
 759                 }
 760
 761                 if (fZoneStringsArray != NULL) {
 762                         fZoneItem = ures_getByKeyWithFallback(fZoneStringsArray, zidkey, fZoneItem, &status);
 763                         if (U_FAILURE(status)) {
 764                                 // If failed to open the zone item, create only location string
 765                                 ures_close(fZoneItem);
 766                                 fZoneItem = NULL;
 767                                 status = U_ZERO_ERROR;
 768                         }
 769                 }
 770
 771                 UnicodeString region;
 772                 getRegion(region);
 773
 774                 zstrarray[ZSIDX_LONG_STANDARD]  = getZoneStringFromBundle(fZoneItem, gLongStandardTag);
 775                 zstrarray[ZSIDX_SHORT_STANDARD] = getZoneStringFromBundle(fZoneItem, gShortStandardTag);
 776                 zstrarray[ZSIDX_LONG_DAYLIGHT]  = getZoneStringFromBundle(fZoneItem, gLongDaylightTag);
 777                 zstrarray[ZSIDX_SHORT_DAYLIGHT] = getZoneStringFromBundle(fZoneItem, gShortDaylightTag);
 778                 zstrarray[ZSIDX_LONG_GENERIC]   = getZoneStringFromBundle(fZoneItem, gLongGenericTag);
 779                 zstrarray[ZSIDX_SHORT_GENERIC]  = getZoneStringFromBundle(fZoneItem, gShortGenericTag);
 780
 781                 // Compose location format string
 782                 UnicodeString location;
 783                 UnicodeString country;
 784                 UnicodeString city;
 785                 UnicodeString countryCode;
 786                 ZoneMeta::getCanonicalCountry(utzid, countryCode);
 787                 if (!countryCode.isEmpty()) {
 788                         const UChar* tmpCity = getZoneStringFromBundle(fZoneItem, gExemplarCityTag);
 789                         if (tmpCity != NULL) {
 790                                 city.setTo(TRUE, tmpCity, -1);
 791                         } else {
 792                                 city.setTo(UnicodeString(pCity, -1, US_INV));
 793                                 // Replace '_' with ' '
 794                                 for (int32_t i = 0; i < city.length(); i++) {
 795                                         if (city.charAt(i) == (UChar)0x5F /*'_'*/) {
 796                                                 city.setCharAt(i, (UChar)0x20 /*' '*/);
 797                                         }
 798                                 }
 799                         }
 800                         getLocalizedCountry(countryCode, fLocale, country);
 801                         UnicodeString singleCountry;
 802                         ZoneMeta::getSingleCountry(utzid, singleCountry);
 803                         FieldPosition fpos;
 804                         if (singleCountry.isEmpty()) {
 805                                 Formattable params [] = {
 806                                         Formattable(city),
 807                                         Formattable(country)
 808                                 };
 809                                 fallbackFmt->format(params, 2, location, fpos, status);
 810                         } else {
 811                                 // If the zone is only one zone in the country, do not add city
 812                                 Formattable params [] = {
 813                                         Formattable(country)
 814                                 };
 815                                 regionFmt->format(params, 1, location, fpos, status);
 816                         }
 817                         if (U_FAILURE(status)) {
 818                                 goto error_cleanup;
 819                         }
 820
 821                         zstrarray[ZSIDX_LOCATION] = location.getTerminatedBuffer();
 822                 } else {
 823                         if (uprv_strlen(tzid) > 4 && uprv_strncmp(tzid, "Etc/", 4) == 0) {
 824                                 // "Etc/xxx" is not associated with a specific location, so localized
 825                                 // GMT format is always used as generic location format.
 826                                 zstrarray[ZSIDX_LOCATION] = NULL;
 827                         } else {
 828                                 // When a new time zone ID, which is actually associated with a specific
 829                                 // location, is added in tzdata, but the current CLDR data does not have
 830                                 // the information yet, ICU creates a generic location string based on
 831                                 // the ID.  This implementation supports canonical time zone round trip
 832                                 // with format pattern "VVVV".  See #6602 for the details.
 833                                 UnicodeString loc(utzid);
 834                                 int32_t slashIdx = loc.lastIndexOf((UChar)0x2f);
 835                                 if (slashIdx == -1) {
 836                                         // A time zone ID without slash in the tz database is not
 837                                         // associated with a specific location.  For instances,
 838                                         // MET, CET, EET and WET fall into this category.
 839                                         // In this case, we still use GMT format as fallback.
 840                                         zstrarray[ZSIDX_LOCATION] = NULL;
 841                                 } else {
 842                                         FieldPosition fpos;
 843                                         Formattable params[] = {
 844                                                 Formattable(loc)
 845                                         };
 846                                         regionFmt->format(params, 1, location, fpos, status);
 847                                         if (U_FAILURE(status)) {
 848                                                 goto error_cleanup;
 849                                         }
 850                                         zstrarray[ZSIDX_LOCATION] = location.getTerminatedBuffer();
 851                                 }
 852                         }
 853                 }
 854
 855                 UBool commonlyUsed = isCommonlyUsed(fZoneItem);
 856
 857                 // Resolve metazones used by this zone
 858                 int32_t mzPartialLocIdx = 0;
 859                 const UVector *metazoneMappings = ZoneMeta::getMetazoneMappings(utzid);
 860                 if (metazoneMappings != NULL) {
 861                         for (int32_t i = 0; i < metazoneMappings->size(); i++) {
 862                                 const OlsonToMetaMappingEntry *mzmap =
 863                                                 (const OlsonToMetaMappingEntry*)metazoneMappings->elementAt(i);
 864                                 UnicodeString mzid(mzmap->mzid);
 865                                 const ZoneStrings *mzStrings =
 866                                         (const ZoneStrings*)uhash_get(fMzidToStrings, mzid.getTerminatedBuffer());
 867                                 if (mzStrings == NULL) {
 868                                         // If the metazone strings are not yet processed, do it now.
 869                                         char mzidkey[ZID_KEY_MAX];
 870                                         uprv_strcpy(mzidkey, gMetazoneIdPrefix);
 871                                         u_UCharsToChars(mzmap->mzid, mzidkey + MZID_PREFIX_LEN, u_strlen(mzmap->mzid) + 1);
 872                                         fMetazoneItem = ures_getByKeyWithFallback(fZoneStringsArray, mzidkey, fMetazoneItem, &status);
 873                                         if (U_FAILURE(status)) {
 874                                                 // No resources available for this metazone
 875                                                 // Resource bundle will be cleaned up after end of the loop.
 876                                                 status = U_ZERO_ERROR;
 877                                                 continue;
 878                                         }
 879                                         UBool mzCommonlyUsed = isCommonlyUsed(fMetazoneItem);
 880                                         mzstrarray[ZSIDX_LONG_STANDARD] = getZoneStringFromBundle(fMetazoneItem, gLongStandardTag);
 881                                         mzstrarray[ZSIDX_SHORT_STANDARD] = getZoneStringFromBundle(fMetazoneItem, gShortStandardTag);
 882                                         mzstrarray[ZSIDX_LONG_DAYLIGHT] = getZoneStringFromBundle(fMetazoneItem, gLongDaylightTag);
 883                                         mzstrarray[ZSIDX_SHORT_DAYLIGHT] = getZoneStringFromBundle(fMetazoneItem, gShortDaylightTag);
 884                                         mzstrarray[ZSIDX_LONG_GENERIC] = getZoneStringFromBundle(fMetazoneItem, gLongGenericTag);
 885                                         mzstrarray[ZSIDX_SHORT_GENERIC] = getZoneStringFromBundle(fMetazoneItem, gShortGenericTag);
 886                                         mzstrarray[ZSIDX_LOCATION] = NULL;
 887
 888                                         int32_t lastNonNullIdx = ZSIDX_COUNT - 1;
 889                                         while (lastNonNullIdx >= 0) {
 890                                                 if (mzstrarray[lastNonNullIdx] != NULL) {
 891                                                         break;
 892                                                 }
 893                                                 lastNonNullIdx--;
 894                                         }
 895                                         UnicodeString *strings_mz = NULL;
 896                                         ZoneStrings *tmp_mzStrings = NULL;
 897                                         if (lastNonNullIdx >= 0) {
 898                                                 // Create UnicodeString array and put strings to the zone string trie
 899                                                 strings_mz = new UnicodeString[lastNonNullIdx + 1];
 900
 901                                                 UnicodeString preferredIdForLocale;
 902                                                 ZoneMeta::getZoneIdByMetazone(mzid, region, preferredIdForLocale);
 903
 904                                                 for (int32_t typeidx = 0; typeidx <= lastNonNullIdx; typeidx++) {
 905                                                         if (mzstrarray[typeidx] != NULL) {
 906                                                                 strings_mz[typeidx].setTo(TRUE, mzstrarray[typeidx], -1);
 907
 908                                                                 // Add a metazone string to the zone string trie
 909                                                                 int32_t type = getTimeZoneTranslationType((TimeZoneTranslationTypeIndex)typeidx);
 910                                                                 ZoneStringInfo *zsinfo = new ZoneStringInfo(
 911                                                                                                                                 preferredIdForLocale,
 912                                                                                                                                 strings_mz[typeidx],
 913                                                                                                                                 (TimeZoneTranslationType)type,
 914                                                                                                                                 fStringPool,
 915                                                                                                                                 status);
 916                                                                 fZoneStringsTrie.put(strings_mz[typeidx], zsinfo, fStringPool, status);
 917                                                                 if (U_FAILURE(status)) {
 918                                                                         delete []strings_mz;
 919                                                                         goto error_cleanup;
 920                                                                 }
 921                                                         }
 922                                                 }
 923                                                 // Note: ZoneStrings constructor adopts and deletes the strings_mz array.
 924                                                 tmp_mzStrings = new ZoneStrings(strings_mz, lastNonNullIdx + 1,
 925                                                                                                                 mzCommonlyUsed, NULL, 0, 0, fStringPool, status);
 926                                         } else {
 927                                                 // Create ZoneStrings with empty contents
 928                                                 tmp_mzStrings = new ZoneStrings(NULL, 0, FALSE, NULL, 0, 0, fStringPool, status);
 929                                         }
 930
 931                                         UChar *umzid = const_cast<UChar *>(fStringPool.get(mzid, status));
 932                                         uhash_put(fMzidToStrings, umzid, tmp_mzStrings, &status);
 933                                         if (U_FAILURE(status)) {
 934                                                 goto error_cleanup;
 935                                         }
 936
 937                                         mzStrings = tmp_mzStrings;
 938                                 }
 939
 940                                 // Compose generic partial location format
 941                                 UnicodeString lg;
 942                                 UnicodeString sg;
 943
 944                                 mzStrings->getString(ZSIDX_LONG_GENERIC, lg);
 945                                 mzStrings->getString(ZSIDX_SHORT_GENERIC, sg);
 946
 947                                 if (!lg.isEmpty() || !sg.isEmpty()) {
 948                                         UBool addMzPartialLocationNames = TRUE;
 949                                         for (int32_t j = 0; j < mzPartialLocIdx; j++) {
 950                                                 if (mzPartialLoc[j][0] == mzid) {
 951                                                         // already processed
 952                                                         addMzPartialLocationNames = FALSE;
 953                                                         break;
 954                                                 }
 955                                         }
 956                                         if (addMzPartialLocationNames) {
 957                                                 UnicodeString *locationPart = NULL;
 958                                                 // Check if the zone is the preferred zone for the territory associated with the zone
 959                                                 UnicodeString preferredID;
 960                                                 ZoneMeta::getZoneIdByMetazone(mzid, countryCode, preferredID);
 961                                                 if (utzid == preferredID) {
 962                                                         // Use country for the location
 963                                                         locationPart = &country;
 964                                                 } else {
 965                                                         // Use city for the location
 966                                                         locationPart = &city;
 967                                                 }
 968                                                 // Reset the partial location string array
 969                                                 mzPartialLoc[mzPartialLocIdx][0].setTo(mzid);
 970                                                 mzPartialLoc[mzPartialLocIdx][1].remove();
 971                                                 mzPartialLoc[mzPartialLocIdx][2].remove();
 972                                                 mzPartialLoc[mzPartialLocIdx][3].remove();
 973
 974                                                 if (locationPart->length() != 0) {
 975                                                         FieldPosition fpos;
 976                                                         if (!lg.isEmpty()) {
 977                                                                 Formattable params [] = {
 978                                                                         Formattable(*locationPart),
 979                                                                         Formattable(lg)
 980                                                                 };
 981                                                                 fallbackFmt->format(params, 2, mzPartialLoc[mzPartialLocIdx][1], fpos, status);
 982                                                         }
 983                                                         if (!sg.isEmpty()) {
 984                                                                 Formattable params [] = {
 985                                                                         Formattable(*locationPart),
 986                                                                         Formattable(sg)
 987                                                                 };
 988                                                                 fallbackFmt->format(params, 2, mzPartialLoc[mzPartialLocIdx][2], fpos, status);
 989                                                                 if (mzStrings->isShortFormatCommonlyUsed()) {
 990                                                                         mzPartialLoc[mzPartialLocIdx][3].setTo(TRUE, gCommonlyUsedTrue, -1);
 991                                                                 }
 992                                                         }
 993                                                         if (U_FAILURE(status)) {
 994                                                                 goto error_cleanup;
 995                                                         }
 996                                                 }
 997                                                 mzPartialLocIdx++;
 998                                         }
 999                                 }
1000                         }
1001                 }
1002                 // Collected names for a zone
1003
1004                 // Create UnicodeString array for localized zone strings
1005                 int32_t lastIdx = ZSIDX_COUNT - 1;
1006                 while (lastIdx >= 0) {
1007                         if (zstrarray[lastIdx] != NULL) {
1008                                 break;
1009                         }
1010                         lastIdx--;
1011                 }
1012                 UnicodeString *strings = NULL;
1013                 int32_t stringsCount = lastIdx + 1;
1014
1015                 if (stringsCount > 0) {
1016                         strings = new UnicodeString[stringsCount];
1017                         for (int32_t i = 0; i < stringsCount; i++) {
1018                                 if (zstrarray[i] != NULL) {
1019                                         strings[i].setTo(zstrarray[i], -1);
1020
1021                                         // Add names to the trie
1022                                         int32_t type = getTimeZoneTranslationType((TimeZoneTranslationTypeIndex)i);
1023                                         ZoneStringInfo *zsinfo = new ZoneStringInfo(utzid,
1024                                                                                                                                 strings[i],
1025                                                                                                                                 (TimeZoneTranslationType)type,
1026                                                                                                                                 fStringPool,
1027                                                                                                                                 status);
1028                                         fZoneStringsTrie.put(strings[i], zsinfo, fStringPool, status);
1029                                         if (U_FAILURE(status)) {
1030                                                 delete zsinfo;
1031                                                 delete[] strings;
1032                                                 goto error_cleanup;
1033                                         }
1034                                 }
1035                         }
1036                 }
1037
1038                 // Create UnicodeString array for generic partial location strings
1039                 UnicodeString **genericPartialLocationNames = NULL;
1040                 int32_t genericPartialRowCount = mzPartialLocIdx;
1041                 int32_t genericPartialColCount = 4;
1042
1043                 if (genericPartialRowCount != 0) {
1044                         genericPartialLocationNames =
1045                                          (UnicodeString**)uprv_malloc(genericPartialRowCount * sizeof(UnicodeString*));
1046                         if (genericPartialLocationNames == NULL) {
1047                                 status = U_MEMORY_ALLOCATION_ERROR;
1048                                 delete[] strings;
1049                                 goto error_cleanup;
1050                         }
1051                         for (int32_t i = 0; i < genericPartialRowCount; i++) {
1052                                 genericPartialLocationNames[i] = new UnicodeString[genericPartialColCount];
1053                                 for (int32_t j = 0; j < genericPartialColCount; j++) {
1054                                         genericPartialLocationNames[i][j].setTo(mzPartialLoc[i][j]);
1055                                         // Add names to the trie
1056                                         if ((j == 1 || j == 2) &&!genericPartialLocationNames[i][j].isEmpty()) {
1057                                                 ZoneStringInfo *zsinfo;
1058                                                 TimeZoneTranslationType type = (j == 1) ? GENERIC_LONG : GENERIC_SHORT;
1059                                                 zsinfo = new ZoneStringInfo(utzid, genericPartialLocationNames[i][j], type,
1060                                                                                                         fStringPool, status);
1061                                                 fZoneStringsTrie.put(genericPartialLocationNames[i][j], zsinfo, fStringPool, status);
1062                                                 if (U_FAILURE(status)) {
1063                                                         delete[] genericPartialLocationNames[i];
1064                                                         uprv_free(genericPartialLocationNames);
1065                                                         delete[] strings;
1066                                                         goto error_cleanup;
1067                                                 }
1068                                         }
1069                                 }
1070                         }
1071                 }
1072
1073                 // Finally, create ZoneStrings instance and put it into the tzidToStinrgs map
1074                 ZoneStrings *zstrings = new ZoneStrings(strings, stringsCount, commonlyUsed,
1075                                                                                                 genericPartialLocationNames, genericPartialRowCount,
1076                                                                                                 genericPartialColCount, fStringPool, status);
1077
1078                 UChar *uutzid = const_cast<UChar *>(fStringPool.get(utzid, status));
1079                 uhash_put(fTzidToStrings, uutzid, zstrings, &status);
1080                 if (U_FAILURE(status)) {
1081                         delete zstrings;
1082                         goto error_cleanup;
1083                 }
1084         }
1085
1086 error_cleanup:
1087     if (fallbackFmt != NULL) {
1088         delete fallbackFmt;
1089     }
1090     if (regionFmt != NULL) {
1091         delete regionFmt;
1092     }
1093     //  fStringPool.freeze();
1094 }
1095
1096 void
1097 ZoneStringFormat::loadFull(UErrorCode &status)
1098 {
1099     if (U_FAILURE(status)) {
1100         return;
1101     }
1102         if (fIsFullyLoaded) {
1103                 return;
1104         }
1105
1106         umtx_lock(&ZoneStringFormatMutex);
1107
1108         if (fZoneStringsArray == NULL) {
1109                 fZoneStringsArray = ures_open(U_ICUDATA_ZONE, fLocale.getName(), &status);
1110                 fZoneStringsArray = ures_getByKeyWithFallback(fZoneStringsArray, gZoneStringsTag, fZoneStringsArray, &status);
1111                 if (U_FAILURE(status)) {
1112                         // If no locale bundles are available, zoneStrings will be null.
1113                         // We still want to go through the rest of zone strings initialization,
1114                         // because generic location format is generated from tzid for the case.
1115                         // The rest of code should work even zoneStrings is null.
1116                         status = U_ZERO_ERROR;
1117                         ures_close(fZoneStringsArray);
1118                         fZoneStringsArray = NULL;
1119                 }
1120     }
1121
1122     StringEnumeration *tzids = NULL;
1123
1124     tzids = TimeZone::createEnumeration();
1125     const char *tzid;
1126     while ((tzid = tzids->next(NULL, status))) {
1127         if (U_FAILURE(status)) {
1128             goto error_cleanup;
1129         }
1130         // Skip non-canonical IDs
1131         UnicodeString utzid(tzid, -1, US_INV);
1132         UnicodeString canonicalID;
1133         TimeZone::getCanonicalID(utzid, canonicalID, status);
1134         if (U_FAILURE(status)) {
1135             // Ignore unknown ID - we should not get here, but just in case.
1136             status = U_ZERO_ERROR;
1137             continue;
1138         }
1139
1140                 if (U_SUCCESS(status)) {
1141                         if (uhash_count(fTzidToStrings) > 0) {
1142                                 ZoneStrings *zstrings = (ZoneStrings*)uhash_get(fTzidToStrings, canonicalID.getTerminatedBuffer());
1143                                 if (zstrings != NULL) {
1144                                         continue;       //      We already about this one
1145                                 }
1146                         }
1147                 }
1148
1149                 addSingleZone(canonicalID, status);
1150
1151         if (U_FAILURE(status)) {
1152                         goto error_cleanup;
1153                 }
1154     }
1155
1156         fIsFullyLoaded = TRUE;
1157
1158 error_cleanup:
1159     if (tzids != NULL) {
1160         delete tzids;
1161     }
1162     fStringPool.freeze();
1163
1164         umtx_unlock(&ZoneStringFormatMutex);
1165 }
1166
1167
1168 ZoneStringFormat::~ZoneStringFormat() {
1169     uhash_close(fTzidToStrings);
1170     uhash_close(fMzidToStrings);
1171     ures_close(fZoneItem);
1172     ures_close(fMetazoneItem);
1173     ures_close(fZoneStringsArray);
1174 }
1175
1176 SafeZoneStringFormatPtr*
1177 ZoneStringFormat::getZoneStringFormat(const Locale& locale, UErrorCode &status) {
1178     umtx_lock(&gZSFCacheLock);
1179     if (gZoneStringFormatCache == NULL) {
1180         gZoneStringFormatCache = new ZSFCache(10 /* capacity */);
1181         ucln_i18n_registerCleanup(UCLN_I18N_ZSFORMAT, zoneStringFormat_cleanup);
1182     }
1183     umtx_unlock(&gZSFCacheLock);
1184
1185     return gZoneStringFormatCache->get(locale, status);
1186 }
1187
1188
1189 UnicodeString**
1190 ZoneStringFormat::createZoneStringsArray(UDate date, int32_t &rowCount, int32_t &colCount, UErrorCode &status) const {
1191     if (U_FAILURE(status)) {
1192         return NULL;
1193     }
1194         ZoneStringFormat *nonConstThis = const_cast<ZoneStringFormat *>(this);
1195         nonConstThis->loadFull(status);
1196
1197     UnicodeString **result = NULL;
1198     rowCount = 0;
1199     colCount = 0;
1200
1201     // Collect canonical time zone IDs
1202     UVector canonicalIDs(uhash_deleteUnicodeString, uhash_compareUnicodeString, status);
1203     if (U_FAILURE(status)) {
1204         return NULL;
1205     }
1206     StringEnumeration *tzids = TimeZone::createEnumeration();
1207     const UChar *tzid;
1208     while ((tzid = tzids->unext(NULL, status))) {
1209         if (U_FAILURE(status)) {
1210             delete tzids;
1211             return NULL;
1212         }
1213         UnicodeString utzid(tzid);
1214         UnicodeString canonicalID;
1215         TimeZone::getCanonicalID(UnicodeString(tzid), canonicalID, status);
1216         if (U_FAILURE(status)) {
1217             // Ignore unknown ID - we should not get here, but just in case.
1218             status = U_ZERO_ERROR;
1219             continue;
1220         }
1221         if (utzid == canonicalID) {
1222             canonicalIDs.addElement(new UnicodeString(utzid), status);
1223             if (U_FAILURE(status)) {
1224                 delete tzids;
1225                 return NULL;
1226             }
1227         }
1228     }
1229     delete tzids;
1230
1231     // Allocate array
1232     result = (UnicodeString**)uprv_malloc(canonicalIDs.size() * sizeof(UnicodeString*));
1233     if (result == NULL) {
1234         status = U_MEMORY_ALLOCATION_ERROR;
1235         return NULL;
1236     }
1237     for (int32_t i = 0; i < canonicalIDs.size(); i++) {
1238         result[i] = new UnicodeString[8];
1239         UnicodeString *id = (UnicodeString*)canonicalIDs.elementAt(i);
1240         result[i][0].setTo(*id);
1241         getLongStandard(*id, date, result[i][1]);
1242         getShortStandard(*id, date, FALSE, result[i][2]);
1243         getLongDaylight(*id, date, result[i][3]);
1244         getShortDaylight(*id, date, FALSE, result[i][4]);
1245         getGenericLocation(*id, result[i][5]);
1246         getLongGenericNonLocation(*id, date, result[i][6]);
1247         getShortGenericNonLocation(*id, date, FALSE, result[i][7]);
1248     }
1249
1250     rowCount = canonicalIDs.size();
1251     colCount = 8;
1252     return result;
1253 }
1254
1255 UnicodeString&
1256 ZoneStringFormat::getSpecificLongString(const Calendar &cal, UnicodeString &result,
1257                                         UErrorCode &status) const {
1258     result.remove();
1259     if (U_FAILURE(status)) {
1260         return result;
1261     }
1262     UnicodeString tzid;
1263     cal.getTimeZone().getID(tzid);
1264     UDate date = cal.getTime(status);
1265     if (cal.get(UCAL_DST_OFFSET, status) == 0) {
1266         return getString(tzid, ZSIDX_LONG_STANDARD, date, FALSE /*not used*/, result);
1267     } else {
1268         return getString(tzid, ZSIDX_LONG_DAYLIGHT, date, FALSE /*not used*/, result);
1269     }
1270 }
1271
1272 UnicodeString&
1273 ZoneStringFormat::getSpecificShortString(const Calendar &cal, UBool commonlyUsedOnly,
1274                                          UnicodeString &result, UErrorCode &status) const {
1275     result.remove();
1276     if (U_FAILURE(status)) {
1277         return result;
1278     }
1279     UnicodeString tzid;
1280     cal.getTimeZone().getID(tzid);
1281     UDate date = cal.getTime(status);
1282     if (cal.get(UCAL_DST_OFFSET, status) == 0) {
1283         return getString(tzid, ZSIDX_SHORT_STANDARD, date, commonlyUsedOnly, result);
1284     } else {
1285         return getString(tzid, ZSIDX_SHORT_DAYLIGHT, date, commonlyUsedOnly, result);
1286     }
1287 }
1288
1289 UnicodeString&
1290 ZoneStringFormat::getGenericLongString(const Calendar &cal, UnicodeString &result,
1291                                        UErrorCode &status) const {
1292     return getGenericString(cal, FALSE /*long*/, FALSE /* not used */, result, status);
1293 }
1294
1295 UnicodeString&
1296 ZoneStringFormat::getGenericShortString(const Calendar &cal, UBool commonlyUsedOnly,
1297                                         UnicodeString &result, UErrorCode &status) const {
1298     return getGenericString(cal, TRUE /*short*/, commonlyUsedOnly, result, status);
1299 }
1300
1301 UnicodeString&
1302 ZoneStringFormat::getGenericLocationString(const Calendar &cal, UnicodeString &result,
1303                                            UErrorCode &status) const {
1304     UnicodeString tzid;
1305     cal.getTimeZone().getID(tzid);
1306     UDate date = cal.getTime(status);
1307     return getString(tzid, ZSIDX_LOCATION, date, FALSE /*not used*/, result);
1308 }
1309
1310 const ZoneStringInfo*
1311 ZoneStringFormat::findSpecificLong(const UnicodeString &text, int32_t start,
1312                                    int32_t &matchLength, UErrorCode &status) const {
1313     return find(text, start, STANDARD_LONG | DAYLIGHT_LONG, matchLength, status);
1314 }
1315
1316 const ZoneStringInfo*
1317 ZoneStringFormat::findSpecificShort(const UnicodeString &text, int32_t start,
1318                                     int32_t &matchLength, UErrorCode &status) const {
1319     return find(text, start, STANDARD_SHORT | DAYLIGHT_SHORT, matchLength, status);
1320 }
1321
1322 const ZoneStringInfo*
1323 ZoneStringFormat::findGenericLong(const UnicodeString &text, int32_t start,
1324                                   int32_t &matchLength, UErrorCode &status) const {
1325     return find(text, start, GENERIC_LONG | STANDARD_LONG | LOCATION, matchLength, status);
1326 }
1327
1328 const ZoneStringInfo*
1329 ZoneStringFormat::findGenericShort(const UnicodeString &text, int32_t start,
1330                                    int32_t &matchLength, UErrorCode &status) const {
1331     return find(text, start, GENERIC_SHORT | STANDARD_SHORT | LOCATION, matchLength, status);
1332 }
1333
1334 const ZoneStringInfo*
1335 ZoneStringFormat::findGenericLocation(const UnicodeString &text, int32_t start,
1336                                       int32_t &matchLength, UErrorCode &status) const {
1337     return find(text, start, LOCATION, matchLength, status);
1338 }
1339
1340 UnicodeString&
1341 ZoneStringFormat::getString(const UnicodeString &tzid, TimeZoneTranslationTypeIndex typeIdx, UDate date,
1342                             UBool commonlyUsedOnly, UnicodeString& result) const {
1343     UErrorCode status = U_ZERO_ERROR;
1344     result.remove();
1345         if (!fIsFullyLoaded) {
1346                 // Lazy loading
1347                 ZoneStringFormat *nonConstThis = const_cast<ZoneStringFormat *>(this);
1348                 nonConstThis->loadZone(tzid, status);
1349         }
1350
1351     // ICU's own array does not have entries for aliases
1352     UnicodeString canonicalID;
1353     TimeZone::getCanonicalID(tzid, canonicalID, status);
1354     if (U_FAILURE(status)) {
1355         // Unknown ID, but users might have their own data.
1356         canonicalID.setTo(tzid);
1357     }
1358
1359     if (uhash_count(fTzidToStrings) > 0) {
1360         ZoneStrings *zstrings = (ZoneStrings*)uhash_get(fTzidToStrings, canonicalID.getTerminatedBuffer());
1361         if (zstrings != NULL) {
1362             switch (typeIdx) {
1363                 case ZSIDX_LONG_STANDARD:
1364                 case ZSIDX_LONG_DAYLIGHT:
1365                 case ZSIDX_LONG_GENERIC:
1366                 case ZSIDX_LOCATION:
1367                     zstrings->getString(typeIdx, result);
1368                     break;
1369                 case ZSIDX_SHORT_STANDARD:
1370                 case ZSIDX_SHORT_DAYLIGHT:
1371                 case ZSIDX_COUNT: //added to avoid warning
1372                 case ZSIDX_SHORT_GENERIC:
1373                     if (!commonlyUsedOnly || zstrings->isShortFormatCommonlyUsed()) {
1374                         zstrings->getString(typeIdx, result);
1375                     }
1376                     break;
1377                 default:
1378                     break;
1379             }
1380         }
1381     }
1382     if (result.isEmpty() && uhash_count(fMzidToStrings) > 0 && typeIdx != ZSIDX_LOCATION) {
1383         // Try metazone
1384         UnicodeString mzid;
1385         ZoneMeta::getMetazoneID(canonicalID, date, mzid);
1386         if (!mzid.isEmpty()) {
1387             ZoneStrings *mzstrings = (ZoneStrings*)uhash_get(fMzidToStrings, mzid.getTerminatedBuffer());
1388             if (mzstrings != NULL) {
1389                 switch (typeIdx) {
1390                     case ZSIDX_LONG_STANDARD:
1391                     case ZSIDX_LONG_DAYLIGHT:
1392                     case ZSIDX_LONG_GENERIC:
1393                     case ZSIDX_LOCATION:
1394                         mzstrings->getString(typeIdx, result);
1395                         break;
1396                     case ZSIDX_SHORT_STANDARD:
1397                     case ZSIDX_SHORT_DAYLIGHT:
1398                     case ZSIDX_COUNT: //added to avoid warning
1399                     case ZSIDX_SHORT_GENERIC:
1400                         if (!commonlyUsedOnly || mzstrings->isShortFormatCommonlyUsed()) {
1401                             mzstrings->getString(typeIdx, result);
1402                         }
1403                         break;
1404                     default:
1405                         break;
1406                 }
1407             }
1408         }
1409     }
1410     return result;
1411 }
1412
1413 UnicodeString&
1414 ZoneStringFormat::getGenericString(const Calendar &cal, UBool isShort, UBool commonlyUsedOnly,
1415                                    UnicodeString &result, UErrorCode &status) const {
1416     result.remove();
1417     UDate time = cal.getTime(status);
1418     if (U_FAILURE(status)) {
1419         return result;
1420     }
1421     const TimeZone &tz = cal.getTimeZone();
1422     UnicodeString tzid;
1423     tz.getID(tzid);
1424
1425         if (!fIsFullyLoaded) {
1426                 // Lazy loading
1427                 ZoneStringFormat *nonConstThis = const_cast<ZoneStringFormat *>(this);
1428                 nonConstThis->loadZone(tzid, status);
1429         }
1430
1431     // ICU's own array does not have entries for aliases
1432     UnicodeString canonicalID;
1433     TimeZone::getCanonicalID(tzid, canonicalID, status);
1434     if (U_FAILURE(status)) {
1435         // Unknown ID, but users might have their own data.
1436         status = U_ZERO_ERROR;
1437         canonicalID.setTo(tzid);
1438     }
1439
1440     ZoneStrings *zstrings = NULL;
1441     if (uhash_count(fTzidToStrings) > 0) {
1442         zstrings = (ZoneStrings*)uhash_get(fTzidToStrings, canonicalID.getTerminatedBuffer());
1443         if (zstrings != NULL) {
1444             if (isShort) {
1445                 if (!commonlyUsedOnly || zstrings->isShortFormatCommonlyUsed()) {
1446                     zstrings->getString(ZSIDX_SHORT_GENERIC, result);
1447                 }
1448             } else {
1449                 zstrings->getString(ZSIDX_LONG_GENERIC, result);
1450             }
1451         }
1452     }
1453     if (result.isEmpty() && uhash_count(fMzidToStrings) > 0) {
1454         // try metazone
1455         int32_t raw, sav;
1456         UnicodeString mzid;
1457         ZoneMeta::getMetazoneID(canonicalID, time, mzid);
1458         if (!mzid.isEmpty()) {
1459             UBool useStandard = FALSE;
1460             sav = cal.get(UCAL_DST_OFFSET, status);
1461             if (U_FAILURE(status)) {
1462                 return result;
1463             }
1464             if (sav == 0) {
1465                 useStandard = TRUE;
1466                 // Check if the zone actually uses daylight saving time around the time
1467                 TimeZone *tmptz = tz.clone();
1468                 BasicTimeZone *btz = NULL;
1469                 if (dynamic_cast<OlsonTimeZone *>(tmptz) != NULL
1470                     || dynamic_cast<SimpleTimeZone *>(tmptz) != NULL
1471                     || dynamic_cast<RuleBasedTimeZone *>(tmptz) != NULL
1472                     || dynamic_cast<VTimeZone *>(tmptz) != NULL) {
1473                     btz = (BasicTimeZone*)tmptz;
1474                 }
1475
1476                 if (btz != NULL) {
1477                     TimeZoneTransition before;
1478                     UBool beforTrs = btz->getPreviousTransition(time, TRUE, before);
1479                     if (beforTrs
1480                             && (time - before.getTime() < kDstCheckRange)
1481                             && before.getFrom()->getDSTSavings() != 0) {
1482                         useStandard = FALSE;
1483                     } else {
1484                         TimeZoneTransition after;
1485                         UBool afterTrs = btz->getNextTransition(time, FALSE, after);
1486                         if (afterTrs
1487                                 && (after.getTime() - time < kDstCheckRange)
1488                                 && after.getTo()->getDSTSavings() != 0) {
1489                             useStandard = FALSE;
1490                         }
1491                     }
1492                 } else {
1493                     // If not BasicTimeZone... only if the instance is not an ICU's implementation.
1494                     // We may get a wrong answer in edge case, but it should practically work OK.
1495                     tmptz->getOffset(time - kDstCheckRange, FALSE, raw, sav, status);
1496                     if (sav != 0) {
1497                         useStandard = FALSE;
1498                     } else {
1499                         tmptz->getOffset(time + kDstCheckRange, FALSE, raw, sav, status);
1500                         if (sav != 0){
1501                             useStandard = FALSE;
1502                         }
1503                     }
1504                     if (U_FAILURE(status)) {
1505                         delete tmptz;
1506                         result.remove();
1507                         return result;
1508                     }
1509                 }
1510                 delete tmptz;
1511             }
1512             if (useStandard) {
1513                 getString(canonicalID, (isShort ? ZSIDX_SHORT_STANDARD : ZSIDX_LONG_STANDARD),
1514                     time, commonlyUsedOnly, result);
1515
1516                 // Note:
1517                 // In CLDR 1.5.1, a same localization is used for both generic and standard
1518                 // for some metazones in some locales.  This is actually data bugs and should
1519                 // be resolved in later versions of CLDR.  For now, we check if the standard
1520                 // name is different from its generic name below.
1521                 if (!result.isEmpty()) {
1522                     UnicodeString genericNonLocation;
1523                     getString(canonicalID, (isShort ? ZSIDX_SHORT_GENERIC : ZSIDX_LONG_GENERIC),
1524                         time, commonlyUsedOnly, genericNonLocation);
1525                     if (!genericNonLocation.isEmpty() && result == genericNonLocation) {
1526                         result.remove();
1527                     }
1528                 }
1529             }
1530             if (result.isEmpty()) {
1531                 ZoneStrings *mzstrings = (ZoneStrings*)uhash_get(fMzidToStrings, mzid.getTerminatedBuffer());
1532                 if (mzstrings != NULL) {
1533                     if (isShort) {
1534                         if (!commonlyUsedOnly || mzstrings->isShortFormatCommonlyUsed()) {
1535                             mzstrings->getString(ZSIDX_SHORT_GENERIC, result);
1536                         }
1537                     } else {
1538                         mzstrings->getString(ZSIDX_LONG_GENERIC, result);
1539                     }
1540                 }
1541                 if (!result.isEmpty()) {
1542                     // Check if the offsets at the given time matches the preferred zone's offsets
1543                     UnicodeString preferredId;
1544                     UnicodeString region;
1545                     ZoneMeta::getZoneIdByMetazone(mzid, getRegion(region), preferredId);
1546                     if (canonicalID != preferredId) {
1547                         // Check if the offsets at the given time are identical with the preferred zone
1548                         raw = cal.get(UCAL_ZONE_OFFSET, status);
1549                         if (U_FAILURE(status)) {
1550                             result.remove();
1551                             return result;
1552                         }
1553                         TimeZone *preferredZone = TimeZone::createTimeZone(preferredId);
1554                         int32_t prfRaw, prfSav;
1555                         // Check offset in preferred time zone with wall time.
1556                         // With getOffset(time, false, preferredOffsets),
1557                         // you may get incorrect results because of time overlap at DST->STD
1558                         // transition.
1559                         preferredZone->getOffset(time + raw + sav, TRUE, prfRaw, prfSav, status);
1560                         delete preferredZone;
1561
1562                         if (U_FAILURE(status)) {
1563                             result.remove();
1564                             return result;
1565                         }
1566                         if ((raw != prfRaw || sav != prfSav) && zstrings != NULL) {
1567                             // Use generic partial location string as fallback
1568                             zstrings->getGenericPartialLocationString(mzid, isShort, commonlyUsedOnly, result);
1569                         }
1570                     }
1571                 }
1572             }
1573         }
1574     }
1575     if (result.isEmpty()) {
1576         // Use location format as the final fallback
1577         getString(canonicalID, ZSIDX_LOCATION, time, FALSE /*not used*/, result);
1578     }
1579
1580     return result;
1581 }
1582
1583 UnicodeString&
1584 ZoneStringFormat::getGenericPartialLocationString(const UnicodeString &tzid, UBool isShort,
1585                                                   UDate date, UBool commonlyUsedOnly, UnicodeString &result) const {
1586     UErrorCode status = U_ZERO_ERROR;
1587     result.remove();
1588         if (!fIsFullyLoaded) {
1589                 // Lazy loading
1590                 ZoneStringFormat *nonConstThis = const_cast<ZoneStringFormat *>(this);
1591                 nonConstThis->loadZone(tzid, status);
1592         }
1593
1594     if (uhash_count(fTzidToStrings) <= 0) {
1595         return result;
1596     }
1597
1598     UnicodeString canonicalID;
1599     TimeZone::getCanonicalID(tzid, canonicalID, status);
1600     if (U_FAILURE(status)) {
1601         // Unknown ID, so no corresponding meta data.
1602         return result;
1603     }
1604
1605     UnicodeString mzid;
1606     ZoneMeta::getMetazoneID(canonicalID, date, mzid);
1607
1608     if (!mzid.isEmpty()) {
1609         ZoneStrings *zstrings = (ZoneStrings*)uhash_get(fTzidToStrings, canonicalID.getTerminatedBuffer());
1610         if (zstrings != NULL) {
1611             zstrings->getGenericPartialLocationString(mzid, isShort, commonlyUsedOnly, result);
1612         }
1613     }
1614     return result;
1615 }
1616
1617 // This method does lazy zone string loading
1618 const ZoneStringInfo*
1619 ZoneStringFormat::find(const UnicodeString &text, int32_t start, int32_t types,
1620                        int32_t &matchLength, UErrorCode &status) const {
1621
1622     if (U_FAILURE(status)) {
1623         return NULL;
1624     }
1625
1626         const ZoneStringInfo *  result = subFind(text, start, types, matchLength, status);
1627         if (fIsFullyLoaded) {
1628                 return result;
1629         }
1630         // When zone string data is partially loaded,
1631         // this method return the result only when
1632         // the input text is fully consumed.
1633         if (result != NULL) {
1634                 UnicodeString tmpString;
1635                 matchLength = (result->getString(tmpString)).length();
1636                 if (text.length() - start == matchLength) {
1637                         return result;
1638                 }
1639         }
1640
1641         // Now load all zone strings
1642         ZoneStringFormat *nonConstThis = const_cast<ZoneStringFormat *>(this);
1643         nonConstThis->loadFull(status);
1644
1645         return subFind(text, start, types, matchLength, status);
1646 }
1647
1648
1649 /*
1650  * Find a prefix matching time zone for the given zone string types.
1651  * @param text The text contains a time zone string
1652  * @param start The start index within the text
1653  * @param types The bit mask representing a set of requested types
1654  * @return If any zone string matched for the requested types, returns a
1655  * ZoneStringInfo for the longest match.  If no matches are found for
1656  * the requested types, returns a ZoneStringInfo for the longest match
1657  * for any other types.  If nothing matches at all, returns null.
1658  */
1659 const ZoneStringInfo*
1660 ZoneStringFormat::subFind(const UnicodeString &text, int32_t start, int32_t types,
1661                        int32_t &matchLength, UErrorCode &status) const {
1662     matchLength = 0;
1663     if (U_FAILURE(status)) {
1664         return NULL;
1665     }
1666     if (fZoneStringsTrie.isEmpty()) {
1667         return NULL;
1668     }
1669
1670     const ZoneStringInfo *result = NULL;
1671     const ZoneStringInfo *fallback = NULL;
1672     int32_t fallbackMatchLen = 0;
1673
1674     ZoneStringSearchResultHandler handler(status);
1675     fZoneStringsTrie.search(text, start, (TextTrieMapSearchResultHandler*)&handler, status);
1676     if (U_SUCCESS(status)) {
1677         int32_t numMatches = handler.countMatches();
1678         for (int32_t i = 0; i < numMatches; i++) {
1679             int32_t tmpMatchLen = 0; // init. output only param to silence gcc
1680             const ZoneStringInfo *tmp = handler.getMatch(i, tmpMatchLen);
1681             if ((types & tmp->fType) != 0) {
1682                 if (result == NULL || matchLength < tmpMatchLen) {
1683                     result = tmp;
1684                     matchLength = tmpMatchLen;
1685                 } else if (matchLength == tmpMatchLen) {
1686                     // Tie breaker - there are some examples that a
1687                     // long standard name is identical with a location
1688                     // name - for example, "Uruguay Time".  In this case,
1689                     // we interpret it as generic, not specific.
1690                     if (tmp->isGeneric() && !result->isGeneric()) {
1691                         result = tmp;
1692                     }
1693                 }
1694             } else if (result == NULL) {
1695                 if (fallback == NULL || fallbackMatchLen < tmpMatchLen) {
1696                     fallback = tmp;
1697                     fallbackMatchLen = tmpMatchLen;
1698                 } else if (fallbackMatchLen == tmpMatchLen) {
1699                     if (tmp->isGeneric() && !fallback->isGeneric()) {
1700                         fallback = tmp;
1701                     }
1702                 }
1703             }
1704         }
1705         if (result == NULL && fallback != NULL) {
1706             result = fallback;
1707             matchLength = fallbackMatchLen;
1708         }
1709     }
1710     return result;
1711 }
1712
1713
1714 UnicodeString&
1715 ZoneStringFormat::getRegion(UnicodeString &region) const {
1716     const char* country = fLocale.getCountry();
1717     // TODO: Utilize addLikelySubtag in Locale to resolve default region
1718     // when the implementation is ready.
1719     region.setTo(UnicodeString(country, -1, US_INV));
1720     return region;
1721 }
1722
1723 MessageFormat*
1724 ZoneStringFormat::getFallbackFormat(const Locale &locale, UErrorCode &status) {
1725     if (U_FAILURE(status)) {
1726         return NULL;
1727     }
1728     UnicodeString pattern(TRUE, gDefFallbackPattern, -1);
1729     UResourceBundle *zoneStringsArray = ures_open(U_ICUDATA_ZONE, locale.getName(), &status);
1730     zoneStringsArray = ures_getByKeyWithFallback(zoneStringsArray, gZoneStringsTag, zoneStringsArray, &status);
1731     int32_t len;
1732     const UChar *flbkfmt = ures_getStringByKeyWithFallback(zoneStringsArray, gFallbackFormatTag, &len, &status);
1733     if (U_SUCCESS(status)) {
1734         pattern.setTo(flbkfmt);
1735     } else {
1736         status = U_ZERO_ERROR;
1737     }
1738     ures_close(zoneStringsArray);
1739
1740     MessageFormat *fallbackFmt = new MessageFormat(pattern, status);
1741     return fallbackFmt;
1742 }
1743
1744 MessageFormat*
1745 ZoneStringFormat::getRegionFormat(const Locale& locale, UErrorCode &status) {
1746     if (U_FAILURE(status)) {
1747         return NULL;
1748     }
1749     UnicodeString pattern(TRUE, gDefRegionPattern, -1);
1750     UResourceBundle *zoneStringsArray = ures_open(U_ICUDATA_ZONE, locale.getName(), &status);
1751     zoneStringsArray = ures_getByKeyWithFallback(zoneStringsArray, gZoneStringsTag, zoneStringsArray, &status);
1752     int32_t len;
1753     const UChar *regionfmt = ures_getStringByKeyWithFallback(zoneStringsArray, gRegionFormatTag, &len, &status);
1754     if (U_SUCCESS(status)) {
1755         pattern.setTo(regionfmt);
1756     } else {
1757         status = U_ZERO_ERROR;
1758     }
1759     ures_close(zoneStringsArray);
1760
1761     MessageFormat *regionFmt = new MessageFormat(pattern, status);
1762     return regionFmt;
1763 }
1764
1765 const UChar*
1766 ZoneStringFormat::getZoneStringFromBundle(const UResourceBundle *zoneitem, const char *key) {
1767     const UChar *str = NULL;
1768     if (zoneitem != NULL) {
1769         UErrorCode status = U_ZERO_ERROR;
1770         int32_t len;
1771         str = ures_getStringByKeyWithFallback(zoneitem, key, &len, &status);
1772         str = fStringPool.adopt(str, status);
1773         if (U_FAILURE(status)) {
1774             str = NULL;
1775         }
1776     }
1777     return str;
1778 }
1779
1780 UBool
1781 ZoneStringFormat::isCommonlyUsed(const UResourceBundle *zoneitem) {
1782     if (zoneitem == NULL) {
1783         return TRUE;
1784     }
1785
1786     UBool commonlyUsed = FALSE;
1787     UErrorCode status = U_ZERO_ERROR;
1788     UResourceBundle *cuRes = ures_getByKey(zoneitem, gCommonlyUsedTag, NULL, &status);
1789     int32_t cuValue = ures_getInt(cuRes, &status);
1790     if (U_SUCCESS(status)) {
1791         if (cuValue == 1) {
1792             commonlyUsed = TRUE;
1793         }
1794     }
1795     ures_close(cuRes);
1796     return commonlyUsed;
1797 }
1798
1799 UnicodeString&
1800 ZoneStringFormat::getLocalizedCountry(const UnicodeString &countryCode, const Locale &locale, UnicodeString &displayCountry) {
1801     // We do not want to use display country names only from the target language bundle
1802     // Note: we should do this in better way.
1803     displayCountry.remove();
1804     int32_t ccLen = countryCode.length();
1805     if (ccLen > 0 && ccLen < ULOC_COUNTRY_CAPACITY) {
1806         UErrorCode status = U_ZERO_ERROR;
1807         UResourceBundle *localeBundle = ures_open(NULL, locale.getName(), &status);
1808         if (U_SUCCESS(status)) {
1809             const char *bundleLocStr = ures_getLocale(localeBundle, &status);
1810             if (U_SUCCESS(status) && uprv_strlen(bundleLocStr) > 0) {
1811                 Locale bundleLoc(bundleLocStr);
1812                 if (uprv_strcmp(bundleLocStr, "root") != 0 &&
1813                     uprv_strcmp(bundleLoc.getLanguage(), locale.getLanguage()) == 0) {
1814                     // Create a fake locale strings
1815                     char tmpLocStr[ULOC_COUNTRY_CAPACITY + 3];
1816                     uprv_strcpy(tmpLocStr, "xx_");
1817                     u_UCharsToChars(countryCode.getBuffer(), &tmpLocStr[3], ccLen);
1818                     tmpLocStr[3 + ccLen] = 0;
1819
1820                     Locale tmpLoc(tmpLocStr);
1821                     tmpLoc.getDisplayCountry(locale, displayCountry);
1822                 }
1823             }
1824         }
1825         ures_close(localeBundle);
1826     }
1827     if (displayCountry.isEmpty()) {
1828         // Use the country code as the fallback
1829         displayCountry.setTo(countryCode);
1830     }
1831     return displayCountry;
1832 }
1833
1834 // ----------------------------------------------------------------------------
1835 /*
1836  * ZoneStrings constructor adopts (and promptly copies and deletes)
1837  *    the input UnicodeString arrays.
1838  */
1839 ZoneStrings::ZoneStrings(UnicodeString *strings,
1840                          int32_t stringsCount,
1841                          UBool commonlyUsed,
1842                          UnicodeString **genericPartialLocationStrings,
1843                          int32_t genericRowCount,
1844                          int32_t genericColCount,
1845                          ZSFStringPool &sp,
1846                          UErrorCode &status)
1847 :   fStrings(NULL),
1848     fStringsCount(stringsCount),
1849     fIsCommonlyUsed(commonlyUsed),
1850     fGenericPartialLocationStrings(NULL),
1851     fGenericPartialLocationRowCount(genericRowCount),
1852     fGenericPartialLocationColCount(genericColCount)
1853 {
1854     if (U_FAILURE(status)) {
1855         return;
1856     }
1857     int32_t i, j;
1858     if (strings != NULL) {
1859         fStrings = (const UChar **)uprv_malloc(sizeof(const UChar **) * stringsCount);
1860         if (fStrings == NULL) {
1861             status = U_MEMORY_ALLOCATION_ERROR;
1862             return;
1863         }
1864         for (i=0; i<fStringsCount; i++) {
1865             fStrings[i] = sp.get(strings[i], status);
1866         }
1867         delete[] strings;
1868     }
1869     if (genericPartialLocationStrings != NULL) {
1870         fGenericPartialLocationStrings =
1871             (const UChar ***)uprv_malloc(sizeof(const UChar ***) * genericRowCount);
1872         if (fGenericPartialLocationStrings == NULL) {
1873             status = U_MEMORY_ALLOCATION_ERROR;
1874             return;
1875         }
1876         for (i=0; i < fGenericPartialLocationRowCount; i++) {
1877             fGenericPartialLocationStrings[i] =
1878                 (const UChar **)uprv_malloc(sizeof(const UChar **) * genericColCount);
1879             if (fGenericPartialLocationStrings[i] == NULL) {
1880                 status = U_MEMORY_ALLOCATION_ERROR;
1881                 continue;   // Continue so that fGenericPartialLocationStrings will not contain uninitialized junk,
1882             }               //   which would crash the destructor.
1883             for (j=0; j<genericColCount; j++) {
1884                 fGenericPartialLocationStrings[i][j] =
1885                         sp.get(genericPartialLocationStrings[i][j], status);
1886             }
1887             delete[] genericPartialLocationStrings[i];
1888         }
1889         uprv_free(genericPartialLocationStrings);
1890     }
1891 }
1892
1893 ZoneStrings::~ZoneStrings() {
1894     uprv_free(fStrings);
1895     if (fGenericPartialLocationStrings != NULL) {
1896         for (int32_t i = 0; i < fGenericPartialLocationRowCount; i++) {
1897             uprv_free(fGenericPartialLocationStrings[i]);
1898         }
1899         uprv_free(fGenericPartialLocationStrings);
1900     }
1901 }
1902
1903
1904 UnicodeString&
1905 ZoneStrings::getString(int32_t typeIdx, UnicodeString &result) const {
1906     if (typeIdx >= 0 && typeIdx < fStringsCount) {
1907         result.setTo(fStrings[typeIdx], -1);
1908     } else {
1909         result.remove();
1910     }
1911     return result;
1912 }
1913
1914 UnicodeString&
1915 ZoneStrings::getGenericPartialLocationString(const UnicodeString &mzid, UBool isShort,
1916                                         UBool commonlyUsedOnly, UnicodeString &result) const {
1917     UBool isSet = FALSE;
1918     if (fGenericPartialLocationColCount >= 2) {
1919         for (int32_t i = 0; i < fGenericPartialLocationRowCount; i++) {
1920             if (mzid.compare(fGenericPartialLocationStrings[i][0], -1) == 0) {
1921                 if (isShort) {
1922                     if (fGenericPartialLocationColCount >= 3) {
1923                         if (!commonlyUsedOnly ||
1924                             fGenericPartialLocationColCount == 3 ||
1925                             fGenericPartialLocationStrings[i][3][0] != 0) {
1926                                 result.setTo(fGenericPartialLocationStrings[i][2], -1);
1927                             isSet = TRUE;
1928                         }
1929                     }
1930                 } else {
1931                     result.setTo(fGenericPartialLocationStrings[i][1], -1);
1932                     isSet = TRUE;
1933                 }
1934                 break;
1935             }
1936         }
1937     }
1938     if (!isSet) {
1939         result.remove();
1940     }
1941     return result;
1942 }
1943
1944 // --------------------------------------------------------------
1945 SafeZoneStringFormatPtr::SafeZoneStringFormatPtr(ZSFCacheEntry *cacheEntry)
1946 : fCacheEntry(cacheEntry) {
1947 }
1948
1949 SafeZoneStringFormatPtr::~SafeZoneStringFormatPtr() {
1950     fCacheEntry->delRef();
1951 }
1952
1953 const ZoneStringFormat*
1954 SafeZoneStringFormatPtr::get() const {
1955     return fCacheEntry->getZoneStringFormat();
1956 }
1957
1958 ZSFCacheEntry::ZSFCacheEntry(const Locale &locale, ZoneStringFormat *zsf, ZSFCacheEntry *next)
1959 : fLocale(locale), fZoneStringFormat(zsf),
1960  fNext(next), fRefCount(1)
1961 {
1962 }
1963
1964 ZSFCacheEntry::~ZSFCacheEntry () {
1965     delete fZoneStringFormat;
1966 }
1967
1968 const ZoneStringFormat*
1969 ZSFCacheEntry::getZoneStringFormat(void) {
1970     return (const ZoneStringFormat*)fZoneStringFormat;
1971 }
1972
1973 void
1974 ZSFCacheEntry::delRef(void) {
1975     umtx_lock(&gZSFCacheLock);
1976     --fRefCount;
1977     umtx_unlock(&gZSFCacheLock);
1978 }
1979
1980 ZSFCache::ZSFCache(int32_t capacity)
1981 : fCapacity(capacity), fFirst(NULL) {
1982 }
1983
1984 ZSFCache::~ZSFCache() {
1985     ZSFCacheEntry *entry = fFirst;
1986     while (entry) {
1987         ZSFCacheEntry *next = entry->fNext;
1988         delete entry;
1989         entry = next;
1990     }
1991 }
1992
1993 SafeZoneStringFormatPtr*
1994 ZSFCache::get(const Locale &locale, UErrorCode &status) {
1995     SafeZoneStringFormatPtr *result = NULL;
1996
1997     // Search the cache entry list
1998     ZSFCacheEntry *entry = NULL;
1999     ZSFCacheEntry *next, *prev;
2000
2001     umtx_lock(&gZSFCacheLock);
2002     entry = fFirst;
2003     prev = NULL;
2004     while (entry) {
2005         next = entry->fNext;
2006         if (entry->fLocale == locale) {
2007             // Add reference count
2008             entry->fRefCount++;
2009
2010             // move the entry to the top
2011             if (entry != fFirst) {
2012                 prev->fNext = next;
2013                 entry->fNext = fFirst;
2014                 fFirst = entry;
2015             }
2016             break;
2017         }
2018         prev = entry;
2019         entry = next;
2020     }
2021     umtx_unlock(&gZSFCacheLock);
2022
2023     // Create a new ZoneStringFormat
2024     if (entry == NULL) {
2025         ZoneStringFormat *zsf = new ZoneStringFormat(locale, status);
2026         if (U_FAILURE(status)) {
2027             delete zsf;
2028             return NULL;
2029         }
2030         if (zsf == NULL) {
2031             status = U_MEMORY_ALLOCATION_ERROR;
2032             return NULL;
2033         }
2034
2035         // Now add the new entry
2036         umtx_lock(&gZSFCacheLock);
2037         // Make sure no other threads already created the one for the same locale
2038         entry = fFirst;
2039         prev = NULL;
2040         while (entry) {
2041             next = entry->fNext;
2042             if (entry->fLocale == locale) {
2043                 // Add reference count
2044                 entry->fRefCount++;
2045
2046                 // move the entry to the top
2047                 if (entry != fFirst) {
2048                     prev->fNext = next;
2049                     entry->fNext = fFirst;
2050                     fFirst = entry;
2051                 }
2052                 break;
2053             }
2054             prev = entry;
2055             entry = next;
2056         }
2057         if (entry == NULL) {
2058             // Add the new one to the top
2059             next = fFirst;
2060             entry = new ZSFCacheEntry(locale, zsf, next);
2061             fFirst = entry;
2062         } else {
2063             delete zsf;
2064         }
2065         umtx_unlock(&gZSFCacheLock);
2066     }
2067
2068     result = new SafeZoneStringFormatPtr(entry);
2069
2070     // Now, delete unused cache entries beyond the capacity
2071     umtx_lock(&gZSFCacheLock);
2072     entry = fFirst;
2073     prev = NULL;
2074     int32_t idx = 1;
2075     while (entry) {
2076         next = entry->fNext;
2077         if (idx >= fCapacity && entry->fRefCount == 0) {
2078             if (entry == fFirst) {
2079                 fFirst = next;
2080             } else {
2081                 prev->fNext = next;
2082             }
2083             delete entry;
2084         } else {
2085             prev = entry;
2086         }
2087         entry = next;
2088         idx++;
2089     }
2090     umtx_unlock(&gZSFCacheLock);
2091
2092     return result;
2093 }
2094
2095
2096 /*
2097  * Zone String Formatter String Pool Implementation
2098  *
2099  *    String pool for (UChar *) strings.  Avoids having repeated copies of the same string.
2100  */
2101
2102 static const int32_t POOL_CHUNK_SIZE = 2000;
2103 struct ZSFStringPoolChunk: public UMemory {
2104     ZSFStringPoolChunk    *fNext;                       // Ptr to next pool chunk
2105     int32_t               fLimit;                       // Index to start of unused area at end of fStrings
2106     UChar                 fStrings[POOL_CHUNK_SIZE];    //  Strings array
2107     ZSFStringPoolChunk();
2108 };
2109
2110 ZSFStringPoolChunk::ZSFStringPoolChunk() {
2111     fNext = NULL;
2112     fLimit = 0;
2113 }
2114
2115 ZSFStringPool::ZSFStringPool(UErrorCode &status) {
2116     fChunks = NULL;
2117     fHash   = NULL;
2118     if (U_FAILURE(status)) {
2119         return;
2120     }
2121     fChunks = new ZSFStringPoolChunk;
2122     if (fChunks == NULL) {
2123         status = U_MEMORY_ALLOCATION_ERROR;
2124         return;
2125     }
2126
2127     fHash   = uhash_open(uhash_hashUChars      /* keyHash */,
2128                          uhash_compareUChars   /* keyComp */,
2129                          uhash_compareUChars   /* valueComp */,
2130                          &status);
2131     if (U_FAILURE(status)) {
2132         return;
2133     }
2134 }
2135
2136
2137 ZSFStringPool::~ZSFStringPool() {
2138     if (fHash != NULL) {
2139         uhash_close(fHash);
2140         fHash = NULL;
2141     }
2142
2143     while (fChunks != NULL) {
2144         ZSFStringPoolChunk *nextChunk = fChunks->fNext;
2145         delete fChunks;
2146         fChunks = nextChunk;
2147     }
2148 }
2149
2150 static const UChar EmptyString = 0;
2151
2152 const UChar *ZSFStringPool::get(const UChar *s, UErrorCode &status) {
2153     const UChar *pooledString;
2154     if (U_FAILURE(status)) {
2155         return &EmptyString;
2156     }
2157
2158     pooledString = static_cast<UChar *>(uhash_get(fHash, s));
2159     if (pooledString != NULL) {
2160         return pooledString;
2161     }
2162
2163     int32_t length = u_strlen(s);
2164     int32_t remainingLength = POOL_CHUNK_SIZE - fChunks->fLimit;
2165     if (remainingLength <= length) {
2166         U_ASSERT(length < POOL_CHUNK_SIZE);
2167         if (length >= POOL_CHUNK_SIZE) {
2168             status = U_INTERNAL_PROGRAM_ERROR;
2169             return &EmptyString;
2170         }
2171         ZSFStringPoolChunk *oldChunk = fChunks;
2172         fChunks = new ZSFStringPoolChunk;
2173         if (fChunks == NULL) {
2174             status = U_MEMORY_ALLOCATION_ERROR;
2175             return &EmptyString;
2176         }
2177         fChunks->fNext = oldChunk;
2178     }
2179
2180     UChar *destString = &fChunks->fStrings[fChunks->fLimit];
2181     u_strcpy(destString, s);
2182     fChunks->fLimit += (length + 1);
2183     uhash_put(fHash, destString, destString, &status);
2184     return destString;
2185 }
2186
2187
2188 //
2189 //  ZSFStringPool::adopt()   Put a string into the hash, but do not copy the string data
2190 //                           into the pool's storage.  Used for strings from resource bundles,
2191 //                           which will perisist for the life of the zone string formatter, and
2192 //                           therefore can be used directly without copying.
2193 const UChar *ZSFStringPool::adopt(const UChar * s, UErrorCode &status) {
2194     const UChar *pooledString;
2195     if (U_FAILURE(status)) {
2196         return &EmptyString;
2197     }
2198     if (s != NULL) {
2199         pooledString = static_cast<UChar *>(uhash_get(fHash, s));
2200         if (pooledString == NULL) {
2201             UChar *ncs = const_cast<UChar *>(s);
2202             uhash_put(fHash, ncs, ncs, &status);
2203         }
2204     }
2205     return s;
2206 }
2207
2208
2209 const UChar *ZSFStringPool::get(const UnicodeString &s, UErrorCode &status) {
2210     UnicodeString &nonConstStr = const_cast<UnicodeString &>(s);
2211     return this->get(nonConstStr.getTerminatedBuffer(), status);
2212 }
2213
2214 /*
2215  * freeze().   Close the hash table that maps to the pooled strings.
2216  *             After freezing, the pool can not be searched or added to,
2217  *             but all existing references to pooled strings remain valid.
2218  *
2219  *             The main purpose is to recover the storage used for the hash.
2220  */
2221 void ZSFStringPool::freeze() {
2222     uhash_close(fHash);
2223     fHash = NULL;
2224 }
2225
2226 U_NAMESPACE_END
2227
2228 #endif /* #if !UCONFIG_NO_FORMATTING */