ICU 56 update step 1

source/i18n/tzgnames.cpp

 /*
 *******************************************************************************
-* Copyright (C) 2011-2013, International Business Machines Corporation and
+* Copyright (C) 2011-2015, International Business Machines Corporation and
 * others. All Rights Reserved.
 *******************************************************************************
 */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 #include "tzgnames.h"
 
@@ skipping 413 matching lines @@
     } else if (regionLen < (int32_t)sizeof(fTargetRegion)) {
         uprv_strcpy(fTargetRegion, region);
     } else {
         fTargetRegion[0] = 0;
     }
 
     // preload generic names for the default zone
     TimeZone *tz = TimeZone::createDefault();
     const UChar *tzID = ZoneMeta::getCanonicalCLDRID(*tz);
     if (tzID != NULL) {
-        loadStrings(UnicodeString(tzID));
+        loadStrings(UnicodeString(TRUE, tzID, -1));
     }
     delete tz;
 }
 
 void
 TZGNCore::cleanup() {
     if (fRegionFormat != NULL) {
         delete fRegionFormat;
     }
     if (fFallbackFormat != NULL) {
@@ skipping 12 matching lines @@
 
 
 UnicodeString&
 TZGNCore::getDisplayName(const TimeZone& tz, UTimeZoneGenericNameType type, UDate date, UnicodeString& name) const {
     name.setToBogus();
     switch (type) {
     case UTZGNM_LOCATION:
         {
             const UChar* tzCanonicalID = ZoneMeta::getCanonicalCLDRID(tz);
             if (tzCanonicalID != NULL) {
-                getGenericLocationName(UnicodeString(tzCanonicalID), name);
+                getGenericLocationName(UnicodeString(TRUE, tzCanonicalID, -1), name);
             }
         }
         break;
     case UTZGNM_LONG:
     case UTZGNM_SHORT:
         formatGenericNonLocationName(tz, type, date, name);
         if (name.isEmpty()) {
             const UChar* tzCanonicalID = ZoneMeta::getCanonicalCLDRID(tz);
             if (tzCanonicalID != NULL) {
-                getGenericLocationName(UnicodeString(tzCanonicalID), name);
+                getGenericLocationName(UnicodeString(TRUE, tzCanonicalID, -1), name);
             }
         }
         break;
     default:
         break;
     }
     return name;
 }
 
 UnicodeString&
@@ skipping 122 matching lines @@
 UnicodeString&
 TZGNCore::formatGenericNonLocationName(const TimeZone& tz, UTimeZoneGenericNameType type, UDate date, UnicodeString& name) const {
     U_ASSERT(type == UTZGNM_LONG || type == UTZGNM_SHORT);
     name.setToBogus();
 
     const UChar* uID = ZoneMeta::getCanonicalCLDRID(tz);
     if (uID == NULL) {
         return name;
     }
 
-    UnicodeString tzID(uID);
+    UnicodeString tzID(TRUE, uID, -1);
 
     // Try to get a name from time zone first
     UTimeZoneNameType nameType = (type == UTZGNM_LONG) ? UTZNM_LONG_GENERIC : UTZNM_SHORT_GENERIC;
     fTimeZoneNames->getTimeZoneDisplayName(tzID, nameType, name);
 
     if (!name.isEmpty()) {
         return name;
     }
 
     // Try meta zone
-    UnicodeString mzID;
+    UChar mzIDBuf[32];
+    UnicodeString mzID(mzIDBuf, 0, UPRV_LENGTHOF(mzIDBuf));
     fTimeZoneNames->getMetaZoneID(tzID, date, mzID);
     if (!mzID.isEmpty()) {
         UErrorCode status = U_ZERO_ERROR;
         UBool useStandard = FALSE;
         int32_t raw, sav;
+        UChar tmpNameBuf[64];
 
         tz.getOffset(date, FALSE, raw, sav, status);
         if (U_FAILURE(status)) {
             return name;
         }
 
         if (sav == 0) {
             useStandard = TRUE;
 
             TimeZone *tmptz = tz.clone();
@@ skipping 37 matching lines @@
                 if (U_FAILURE(status)) {
                     delete tmptz;
                     return name;
                 }
             }
             delete tmptz;
         }
         if (useStandard) {
             UTimeZoneNameType stdNameType = (nameType == UTZNM_LONG_GENERIC)
                 ? UTZNM_LONG_STANDARD : UTZNM_SHORT_STANDARD;
-            UnicodeString stdName;
+            UnicodeString stdName(tmpNameBuf, 0, UPRV_LENGTHOF(tmpNameBuf));
             fTimeZoneNames->getDisplayName(tzID, stdNameType, date, stdName);
             if (!stdName.isEmpty()) {
                 name.setTo(stdName);
 
                 // TODO: revisit this issue later
                 // In CLDR, a same display name is used for both generic and standard
                 // for some meta zones in some locales.  This looks like a data bugs.
                 // For now, we check if the standard name is different from its generic
                 // name below.
-                UnicodeString mzGenericName;
+                UChar genNameBuf[64];
+                UnicodeString mzGenericName(genNameBuf, 0, UPRV_LENGTHOF(genNameBuf));
                 fTimeZoneNames->getMetaZoneDisplayName(mzID, nameType, mzGenericName);
                 if (stdName.caseCompare(mzGenericName, 0) == 0) {
                     name.setToBogus();
                 }
             }
         }
         if (name.isEmpty()) {
             // Get a name from meta zone
-            UnicodeString mzName;
+            UnicodeString mzName(tmpNameBuf, 0, UPRV_LENGTHOF(tmpNameBuf));
             fTimeZoneNames->getMetaZoneDisplayName(mzID, nameType, mzName);
             if (!mzName.isEmpty()) {
                 // Check if we need to use a partial location format.
                 // This check is done by comparing offset with the meta zone's
                 // golden zone at the given date.
-                UnicodeString goldenID;
+                UChar idBuf[32];
+                UnicodeString goldenID(idBuf, 0, UPRV_LENGTHOF(idBuf));
                 fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, goldenID);
                 if (!goldenID.isEmpty() && goldenID != tzID) {
                     TimeZone *goldenZone = TimeZone::createTimeZone(goldenID);
                     int32_t raw1, sav1;
 
                     // Check offset in the golden zone with wall time.
                     // With getOffset(date, false, offsets1),
                     // you may get incorrect results because of time overlap at DST->STD
                     // transition.
                     goldenZone->getOffset(date + raw + sav, TRUE, raw1, sav1, status);
@@ skipping 445 matching lines @@
     uprv_free(entry);
 }
 U_CDECL_END
 
 /**
  * Function used for removing unreferrenced cache entries exceeding
  * the expiration time. This function must be called with in the mutex
  * block.
  */
 static void sweepCache() {
-    int32_t pos = -1;
+    int32_t pos = UHASH_FIRST;
     const UHashElement* elem;
     double now = (double)uprv_getUTCtime();
 
     while ((elem = uhash_nextElement(gTZGNCoreCache, &pos))) {
         TZGNCoreRef *entry = (TZGNCoreRef *)elem->value.pointer;
         if (entry->refCount <= 0 && (now - entry->lastAccess) > CACHE_EXPIRATION) {
             // delete this entry
             uhash_removeElement(gTZGNCoreCache, elem);
         }
     }
@@ skipping 141 matching lines @@
 }
 
 int32_t
 TimeZoneGenericNames::findBestMatch(const UnicodeString& text, int32_t start, uint32_t types,
         UnicodeString& tzID, UTimeZoneFormatTimeType& timeType, UErrorCode& status) const {
     return fRef->obj->findBestMatch(text, start, types, tzID, timeType, status);
 }
 
 U_NAMESPACE_END
 #endif