ICU 56 update step 1

source/i18n/tzfmt.cpp

 /*
 *******************************************************************************
-* Copyright (C) 2011-2014, 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 "unicode/calendar.h"
 #include "unicode/tzfmt.h"
@@ skipping 345 matching lines @@
         if (len > 0) {
             hourFormats = resStr;
         }
         ures_close(zoneStringsArray);
         ures_close(zoneBundle);
     }
 
     if (gmtPattern == NULL) {
         gmtPattern = DEFAULT_GMT_PATTERN;
     }
-    initGMTPattern(UnicodeString(gmtPattern, -1), status);
+    initGMTPattern(UnicodeString(TRUE, gmtPattern, -1), status);
 
     UBool useDefaultOffsetPatterns = TRUE;
     if (hourFormats) {
         UChar *sep = u_strchr(hourFormats, (UChar)0x003B /* ';' */);
         if (sep != NULL) {
             UErrorCode tmpStatus = U_ZERO_ERROR;
             fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM].setTo(FALSE, hourFormats, (int32_t)(sep - hourFormats));
             fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM].setTo(TRUE, sep + 1, -1);
             expandOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HMS], tmpStatus);
             expandOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HMS], tmpStatus);
@@ skipping 20 matching lines @@
         UnicodeString digits = ns->getDescription();
         useDefDigits = !toCodePoints(digits, fGMTOffsetDigits, 10);
     }
     if (useDefDigits) {
         uprv_memcpy(fGMTOffsetDigits, DEFAULT_GMT_DIGITS, sizeof(UChar32) * 10);
     }
     delete ns;
 }
 
 TimeZoneFormat::TimeZoneFormat(const TimeZoneFormat& other)
-: Format(other), fTimeZoneNames(NULL), fTimeZoneGenericNames(NULL) {
+: Format(other), fTimeZoneNames(NULL), fTimeZoneGenericNames(NULL),
+  fTZDBTimeZoneNames(NULL) {
 
     for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
         fGMTOffsetPatternItems[i] = NULL;
     }
     *this = other;
 }
 
 
 TimeZoneFormat::~TimeZoneFormat() {
     delete fTimeZoneNames;
     delete fTimeZoneGenericNames;
     delete fTZDBTimeZoneNames;
     for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
         delete fGMTOffsetPatternItems[i];
     }
 }
 
 TimeZoneFormat&
 TimeZoneFormat::operator=(const TimeZoneFormat& other) {
     if (this == &other) {
         return *this;
     }
 
     delete fTimeZoneNames;
     delete fTimeZoneGenericNames;
     fTimeZoneGenericNames = NULL;
+    delete fTZDBTimeZoneNames;
+    fTZDBTimeZoneNames = NULL;
 
     fLocale = other.fLocale;
     uprv_memcpy(fTargetRegion, other.fTargetRegion, sizeof(fTargetRegion));
 
     fTimeZoneNames = other.fTimeZoneNames->clone();
     if (other.fTimeZoneGenericNames) {
         // TODO: this test has dubious thread safety.
         fTimeZoneGenericNames = other.fTimeZoneGenericNames->clone();
     }
 
     fGMTPattern = other.fGMTPattern;
     fGMTPatternPrefix = other.fGMTPatternPrefix;
     fGMTPatternSuffix = other.fGMTPatternSuffix;
 
     UErrorCode status = U_ZERO_ERROR;
     for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
         fGMTOffsetPatterns[i] = other.fGMTOffsetPatterns[i];
         delete fGMTOffsetPatternItems[i];
+        fGMTOffsetPatternItems[i] = NULL;
     }
     initGMTOffsetPatterns(status);
     U_ASSERT(U_SUCCESS(status));
 
     fGMTZeroFormat = other.fGMTZeroFormat;
 
     uprv_memcpy(fGMTOffsetDigits, other.fGMTOffsetDigits, sizeof(fGMTOffsetDigits));
 
     fDefParseOptionFlags = other.fDefParseOptionFlags;
 
@@ skipping 308 matching lines @@
         if (tz == NULL) {
             const Calendar* cal = dynamic_cast<const Calendar*>(formatObj);
             if (cal != NULL) {
                 tz = &cal->getTimeZone();
                 date = cal->getTime(status);
             }
         }
         if (tz != NULL) {
             int32_t rawOffset, dstOffset;
             tz->getOffset(date, FALSE, rawOffset, dstOffset, status);
-            UnicodeString result;
+            UChar buf[32];
+            UnicodeString result(buf, 0, UPRV_LENGTHOF(buf));
             formatOffsetLocalizedGMT(rawOffset + dstOffset, result, status);
             if (U_SUCCESS(status)) {
                 appendTo.append(result);
                 if (pos.getField() == UDAT_TIMEZONE_FIELD) {
                     pos.setBeginIndex(0);
                     pos.setEndIndex(result.length());
                 }
             }
         }
     }
@@ skipping 45 matching lines @@
             parsedOffset = offset;
             parsedPos = tmpPos.getIndex();
         }
         // Note: For now, no distinction between long/short localized GMT format in the parser.
         // This might be changed in future.
         // evaluated |= (fallbackLocalizedGMT ? STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT] : STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT]);
         evaluated |= STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT] | STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT];
     }
 
     UErrorCode status = U_ZERO_ERROR;
-    UnicodeString tzID;
+    UChar tzIDBuf[32];
+    UnicodeString tzID(tzIDBuf, 0, UPRV_LENGTHOF(tzIDBuf));
 
     UBool parseTZDBAbbrev = ((parseOptions & UTZFMT_PARSE_OPTION_TZ_DATABASE_ABBREVIATIONS) != 0);
 
     // Try the specified style
     switch (style) {
     case UTZFMT_STYLE_LOCALIZED_GMT:
         {
             tmpPos.setIndex(startIdx);
             tmpPos.setErrorIndex(-1);
 
@@ skipping 228 matching lines @@
         // zero format). Then, it tried to find a match within the set of display names, but could not
         // find a match. At this point, we can safely assume the input text contains the localized
         // GMT format.
         U_ASSERT(parsedOffset != UNKNOWN_OFFSET);
         pos.setIndex(parsedPos);
         return createTimeZoneForOffset(parsedOffset);
     }
 
     // Failed to parse the input text as the time zone format in the specified style.
     // Check the longest match among other styles below.
-    UnicodeString parsedID;
+    UChar parsedIDBuf[32];
+    UnicodeString parsedID(parsedIDBuf, 0, UPRV_LENGTHOF(parsedIDBuf));
     UTimeZoneFormatTimeType parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
 
     U_ASSERT(parsedPos < 0);
     U_ASSERT(parsedOffset == UNKNOWN_OFFSET);
 
     // ISO 8601
     if (parsedPos < maxPos &&
         ((evaluated & ISO_Z_STYLE_FLAG) == 0 || (evaluated & ISO_LOCAL_STYLE_FLAG) == 0)) {
         tmpPos.setIndex(startIdx);
         tmpPos.setErrorIndex(-1);
@@ skipping 214 matching lines @@
         name.setToBogus();
         return name;
     }
 
     if (genType == UTZGNM_LOCATION) {
         const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz);
         if (canonicalID == NULL) {
             name.setToBogus();
             return name;
         }
-        return gnames->getGenericLocationName(UnicodeString(canonicalID), name);
+        return gnames->getGenericLocationName(UnicodeString(TRUE, canonicalID, -1), name);
     }
     return gnames->getDisplayName(tz, (UTimeZoneGenericNameType)genType, date, name);
 }
 
 UnicodeString&
 TimeZoneFormat::formatSpecific(const TimeZone& tz, UTimeZoneNameType stdType, UTimeZoneNameType dstType,
         UDate date, UnicodeString& name, UTimeZoneFormatTimeType *timeType) const {
     if (fTimeZoneNames == NULL) {
         name.setToBogus();
         return name;
     }
 
     UErrorCode status = U_ZERO_ERROR;
     UBool isDaylight = tz.inDaylightTime(date, status);
     const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz);
 
     if (U_FAILURE(status) || canonicalID == NULL) {
         name.setToBogus();
         return name;
     }
 
     if (isDaylight) {
-        fTimeZoneNames->getDisplayName(UnicodeString(canonicalID), dstType, date, name);
+        fTimeZoneNames->getDisplayName(UnicodeString(TRUE, canonicalID, -1), dstType, date, name);
     } else {
-        fTimeZoneNames->getDisplayName(UnicodeString(canonicalID), stdType, date, name);
+        fTimeZoneNames->getDisplayName(UnicodeString(TRUE, canonicalID, -1), stdType, date, name);
     }
 
     if (timeType && !name.isEmpty()) {
         *timeType = isDaylight ? UTZFMT_TIME_TYPE_DAYLIGHT : UTZFMT_TIME_TYPE_STANDARD;
     }
     return name;
 }
 
 const TimeZoneGenericNames*
 TimeZoneFormat::getTimeZoneGenericNames(UErrorCode& status) const {
@@ skipping 27 matching lines @@
             nonConstThis->fTZDBTimeZoneNames = tzdbNames;
         }
     }
     umtx_unlock(&gLock);
 
     return fTZDBTimeZoneNames;
 }
 
 UnicodeString&
 TimeZoneFormat::formatExemplarLocation(const TimeZone& tz, UnicodeString& name) const {
-    UnicodeString location;
+    UChar locationBuf[64];
+    UnicodeString location(locationBuf, 0, UPRV_LENGTHOF(locationBuf));
     const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz);
 
     if (canonicalID) {
-        fTimeZoneNames->getExemplarLocationName(UnicodeString(canonicalID), location);
+        fTimeZoneNames->getExemplarLocationName(UnicodeString(TRUE, canonicalID, -1), location);
     }
     if (location.length() > 0) {
         name.setTo(location);
     } else {
         // Use "unknown" location
-        fTimeZoneNames->getExemplarLocationName(UnicodeString(UNKNOWN_ZONE_ID), location);
+        fTimeZoneNames->getExemplarLocationName(UnicodeString(TRUE, UNKNOWN_ZONE_ID, -1), location);
         if (location.length() > 0) {
             name.setTo(location);
         } else {
             // last resort
             name.setTo(UNKNOWN_LOCATION, -1);
         }
     }
     return name;
 }
 
@@ skipping 967 matching lines @@
     }
     UVector* result = new UVector(deleteGMTOffsetField, NULL, status);
     if (result == NULL) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return NULL;
     }
 
     int32_t checkBits = 0;
     UBool isPrevQuote = FALSE;
     UBool inQuote = FALSE;
-    UnicodeString text;
+    UChar textBuf[32];
+    UnicodeString text(textBuf, 0, UPRV_LENGTHOF(textBuf));
     GMTOffsetField::FieldType itemType = GMTOffsetField::TEXT;
     int32_t itemLength = 1;
 
     for (int32_t i = 0; i < pattern.length(); i++) {
         UChar ch = pattern.charAt(i);
         if (ch == SINGLEQUOTE) {
             if (isPrevQuote) {
                 text.append(SINGLEQUOTE);
                 isPrevQuote = FALSE;
             } else {
@@ skipping 225 matching lines @@
         start = str.moveIndex32(start, 1);
     }
 
     return TRUE;
 }
 
 TimeZone*
 TimeZoneFormat::createTimeZoneForOffset(int32_t offset) const {
     if (offset == 0) {
         // when offset is 0, we should use "Etc/GMT"
-        return TimeZone::createTimeZone(UnicodeString(TZID_GMT));
+        return TimeZone::createTimeZone(UnicodeString(TRUE, TZID_GMT, -1));
     }
     return ZoneMeta::createCustomTimeZone(offset);
 }
 
 UTimeZoneFormatTimeType
 TimeZoneFormat::getTimeType(UTimeZoneNameType nameType) {
     switch (nameType) {
     case UTZNM_LONG_STANDARD:
     case UTZNM_SHORT_STANDARD:
         return UTZFMT_TIME_TYPE_STANDARD;
 
     case UTZNM_LONG_DAYLIGHT:
     case UTZNM_SHORT_DAYLIGHT:
         return UTZFMT_TIME_TYPE_DAYLIGHT;
 
     default:
         return UTZFMT_TIME_TYPE_UNKNOWN;
     }
 }
 
 UnicodeString&
 TimeZoneFormat::getTimeZoneID(const TimeZoneNames::MatchInfoCollection* matches, int32_t idx, UnicodeString& tzID) const {
     if (!matches->getTimeZoneIDAt(idx, tzID)) {
-        UnicodeString mzID;
+        UChar mzIDBuf[32];
+        UnicodeString mzID(mzIDBuf, 0, UPRV_LENGTHOF(mzIDBuf));
         if (matches->getMetaZoneIDAt(idx, mzID)) {
             fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, tzID);
         }
     }
     return tzID;
 }
 
 
 class ZoneIdMatchHandler : public TextTrieMapSearchResultHandler {
 public:
@@ skipping 170 matching lines @@
     if (tzID.length() == 0) {
         pos.setErrorIndex(startIdx);
     }
 
     return tzID;
 }
 
 U_NAMESPACE_END
 
 #endif