Update ICU to 54.1 step 1

source/i18n/tmutfmt.cpp

 /*
  *******************************************************************************
- * Copyright (C) 2008-2013, Google, International Business Machines Corporation
+ * Copyright (C) 2008-2014, Google, International Business Machines Corporation
  * and others. All Rights Reserved.
  *******************************************************************************
  */
 
-#include "utypeinfo.h"  // for 'typeid' to work
-
 #include "unicode/tmutfmt.h"
 
 #if !UCONFIG_NO_FORMATTING
 
+#include "unicode/decimfmt.h"
+#include "plurrule_impl.h"
 #include "uvector.h"
 #include "charstr.h"
 #include "cmemory.h"
 #include "cstring.h"
 #include "hash.h"
 #include "uresimp.h"
+#include "ureslocs.h"
 #include "unicode/msgfmt.h"
 #include "uassert.h"
 
 #define LEFT_CURLY_BRACKET  ((UChar)0x007B)
 #define RIGHT_CURLY_BRACKET ((UChar)0x007D)
 #define SPACE             ((UChar)0x0020)
 #define DIGIT_ZERO        ((UChar)0x0030)
 #define LOW_S             ((UChar)0x0073)
 #define LOW_M             ((UChar)0x006D)
 #define LOW_I             ((UChar)0x0069)
@@ skipping 39 matching lines @@
 static const UChar DEFAULT_PATTERN_FOR_HOUR[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_H, 0};
 static const UChar DEFAULT_PATTERN_FOR_WEEK[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_W, 0};
 static const UChar DEFAULT_PATTERN_FOR_DAY[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_D, 0};
 static const UChar DEFAULT_PATTERN_FOR_MONTH[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_M, 0};
 static const UChar DEFAULT_PATTERN_FOR_YEAR[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_Y, 0};
 
 static const UChar PLURAL_COUNT_ZERO[] = {LOW_Z, LOW_E, LOW_R, LOW_O, 0};
 static const UChar PLURAL_COUNT_ONE[] = {LOW_O, LOW_N, LOW_E, 0};
 static const UChar PLURAL_COUNT_TWO[] = {LOW_T, LOW_W, LOW_O, 0};
 
-TimeUnitFormat::TimeUnitFormat(UErrorCode& status)
-:   fNumberFormat(NULL),
-    fPluralRules(NULL) {
-    create(Locale::getDefault(), UTMUTFMT_FULL_STYLE, status);
+TimeUnitFormat::TimeUnitFormat(UErrorCode& status) {
+    initMeasureFormat(Locale::getDefault(), UMEASFMT_WIDTH_WIDE, NULL, status);
+    create(UTMUTFMT_FULL_STYLE, status);
 }
 
 
-TimeUnitFormat::TimeUnitFormat(const Locale& locale, UErrorCode& status)
-:   fNumberFormat(NULL),
-    fPluralRules(NULL) {
-    create(locale, UTMUTFMT_FULL_STYLE, status);
+TimeUnitFormat::TimeUnitFormat(const Locale& locale, UErrorCode& status) {
+    initMeasureFormat(locale, UMEASFMT_WIDTH_WIDE, NULL, status);
+    create(UTMUTFMT_FULL_STYLE, status);
 }
 
 
-TimeUnitFormat::TimeUnitFormat(const Locale& locale, UTimeUnitFormatStyle style, UErrorCode& status)
-:   fNumberFormat(NULL),
-    fPluralRules(NULL) {
-    create(locale, style, status);
+TimeUnitFormat::TimeUnitFormat(const Locale& locale, UTimeUnitFormatStyle style, UErrorCode& status) {
+    switch (style) {
+    case UTMUTFMT_FULL_STYLE:
+        initMeasureFormat(locale, UMEASFMT_WIDTH_WIDE, NULL, status);
+        break;
+    case UTMUTFMT_ABBREVIATED_STYLE:
+        initMeasureFormat(locale, UMEASFMT_WIDTH_SHORT, NULL, status);
+        break;
+    default:
+        initMeasureFormat(locale, UMEASFMT_WIDTH_WIDE, NULL, status);
+        break;
+    }
+    create(style, status);
 }
 
-
 TimeUnitFormat::TimeUnitFormat(const TimeUnitFormat& other)
 :   MeasureFormat(other),
-    fNumberFormat(NULL),
-    fPluralRules(NULL),
-    fStyle(UTMUTFMT_FULL_STYLE)
+    fStyle(other.fStyle)
 {
     for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
          i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
          i = (TimeUnit::UTimeUnitFields)(i+1)) {
-        fTimeUnitToCountToPatterns[i] = NULL;
-    }
-    *this = other;
+        UErrorCode status = U_ZERO_ERROR;
+        fTimeUnitToCountToPatterns[i] = initHash(status);
+        if (U_SUCCESS(status)) {
+            copyHash(other.fTimeUnitToCountToPatterns[i], fTimeUnitToCountToPatterns[i], status);
+        } else {
+            delete fTimeUnitToCountToPatterns[i];
+            fTimeUnitToCountToPatterns[i] = NULL;
+        }
+    } 
 }
 
 
 TimeUnitFormat::~TimeUnitFormat() {
-    delete fNumberFormat;
-    fNumberFormat = NULL;
     for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
          i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
          i = (TimeUnit::UTimeUnitFields)(i+1)) {
         deleteHash(fTimeUnitToCountToPatterns[i]);
         fTimeUnitToCountToPatterns[i] = NULL;
     }
-    delete fPluralRules;
-    fPluralRules = NULL;
 }
 
 
 Format* 
 TimeUnitFormat::clone(void) const {
     return new TimeUnitFormat(*this);
 }
 
 
 TimeUnitFormat& 
 TimeUnitFormat::operator=(const TimeUnitFormat& other) {
     if (this == &other) {
         return *this;
     }
-    delete fNumberFormat;
+    MeasureFormat::operator=(other);
     for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
          i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
          i = (TimeUnit::UTimeUnitFields)(i+1)) {
         deleteHash(fTimeUnitToCountToPatterns[i]);
         fTimeUnitToCountToPatterns[i] = NULL;
     }
-    delete fPluralRules;
-    if (other.fNumberFormat) {
-        fNumberFormat = (NumberFormat*)other.fNumberFormat->clone();
-    } else {
-        fNumberFormat = NULL;
-    }
-    fLocale = other.fLocale;
     for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
          i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
          i = (TimeUnit::UTimeUnitFields)(i+1)) {
         UErrorCode status = U_ZERO_ERROR;
         fTimeUnitToCountToPatterns[i] = initHash(status);
         if (U_SUCCESS(status)) {
             copyHash(other.fTimeUnitToCountToPatterns[i], fTimeUnitToCountToPatterns[i], status);
         } else {
             delete fTimeUnitToCountToPatterns[i];
             fTimeUnitToCountToPatterns[i] = NULL;
         }
     } 
-    if (other.fPluralRules) {
-        fPluralRules = (PluralRules*)other.fPluralRules->clone();
-    } else {
-        fPluralRules = NULL;
-    }
     fStyle = other.fStyle;
     return *this;
 }
 
-
-UBool 
-TimeUnitFormat::operator==(const Format& other) const {
-    if (typeid(*this) == typeid(other)) {
-        TimeUnitFormat* fmt = (TimeUnitFormat*)&other;
-        UBool ret =  ( ((fNumberFormat && fmt->fNumberFormat && *fNumberFormat == *fmt->fNumberFormat)
-                            || fNumberFormat == fmt->fNumberFormat ) 
-                        && fLocale == fmt->fLocale 
-                        && ((fPluralRules && fmt->fPluralRules && *fPluralRules == *fmt->fPluralRules) 
-                            || fPluralRules == fmt->fPluralRules) 
-                        && fStyle == fmt->fStyle); 
-        if (ret) {
-            for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
-                 i < TimeUnit::UTIMEUNIT_FIELD_COUNT && ret;
-                 i = (TimeUnit::UTimeUnitFields)(i+1)) {
-                ret = fTimeUnitToCountToPatterns[i]->equals(*(fmt->fTimeUnitToCountToPatterns[i]));
-            }
-        }
-        return ret;
-    }
-    return false;
-}
-
-
-UnicodeString& 
-TimeUnitFormat::format(const Formattable& obj, UnicodeString& toAppendTo,
-                       FieldPosition& pos, UErrorCode& status) const {
-    if (U_FAILURE(status)) {
-        return toAppendTo;
-    }
-    if (obj.getType() == Formattable::kObject) {
-        const UObject* formatObj = obj.getObject();
-        const TimeUnitAmount* amount = dynamic_cast<const TimeUnitAmount*>(formatObj);
-        if (amount != NULL){
-            Hashtable* countToPattern = fTimeUnitToCountToPatterns[amount->getTimeUnitField()];
-            double number;
-            const Formattable& amtNumber = amount->getNumber();
-            if (amtNumber.getType() == Formattable::kDouble) {
-                number = amtNumber.getDouble();
-            } else if (amtNumber.getType() == Formattable::kLong) {
-                number = amtNumber.getLong();
-            } else {
-                status = U_ILLEGAL_ARGUMENT_ERROR;
-                return toAppendTo;
-            }
-            UnicodeString count = fPluralRules->select(number);
-#ifdef TMUTFMT_DEBUG
-            char result[1000];
-            count.extract(0, count.length(), result, "UTF-8");
-            std::cout << "number: " << number << "; format plural count: " << result << "\n";           
-#endif
-            MessageFormat* pattern = ((MessageFormat**)countToPattern->get(count))[fStyle];
-            Formattable formattable[1];
-            formattable[0].setDouble(number);
-            return pattern->format(formattable, 1, toAppendTo, pos, status);
-        }
-    }
-    status = U_ILLEGAL_ARGUMENT_ERROR;
-    return toAppendTo;
-}
-
-
 void 
 TimeUnitFormat::parseObject(const UnicodeString& source, 
                             Formattable& result,
                             ParsePosition& pos) const {
-    double resultNumber = -1; 
+    Formattable resultNumber(0.0); 
     UBool withNumberFormat = false;
     TimeUnit::UTimeUnitFields resultTimeUnit = TimeUnit::UTIMEUNIT_FIELD_COUNT;
     int32_t oldPos = pos.getIndex();
     int32_t newPos = -1;
     int32_t longestParseDistance = 0;
     UnicodeString* countOfLongestMatch = NULL;
 #ifdef TMUTFMT_DEBUG
     char res[1000];
     source.extract(0, source.length(), res, "UTF-8");
     std::cout << "parse source: " << res << "\n";           
@@ skipping 23 matching lines @@
                 pos.setIndex(oldPos);
                 // see if we can parse
                 Formattable parsed;
                 pattern->parseObject(source, parsed, pos);
                 if (pos.getErrorIndex() != -1 || pos.getIndex() == oldPos) {
                     continue;
                 }
     #ifdef TMUTFMT_DEBUG
                 std::cout << "parsed.getType: " << parsed.getType() << "\n";
     #endif
-                double tmpNumber = 0;
+                Formattable tmpNumber(0.0);
                 if (pattern->getArgTypeCount() != 0) {
-                    // pattern with Number as beginning, such as "{0} d".
-                    // check to make sure that the timeUnit is consistent
                     Formattable& temp = parsed[0];
-                    if (temp.getType() == Formattable::kDouble) {
-                        tmpNumber = temp.getDouble();
-                    } else if (temp.getType() == Formattable::kLong) {
-                        tmpNumber = temp.getLong();
+                    if (temp.getType() == Formattable::kString) {
+                        UnicodeString tmpString;
+                        UErrorCode pStatus = U_ZERO_ERROR;
+                        getNumberFormat().parse(temp.getString(tmpString), tmpNumber, pStatus);
+                        if (U_FAILURE(pStatus)) {
+                            continue;
+                        }
+                    } else if (temp.isNumeric()) {
+                        tmpNumber = temp;
                     } else {
                         continue;
                     }
-                    UnicodeString select = fPluralRules->select(tmpNumber);
-    #ifdef TMUTFMT_DEBUG
-                    select.extract(0, select.length(), res, "UTF-8");
-                    std::cout << "parse plural select count: " << res << "\n"; 
-    #endif
-                    if (*count != select) {
-                        continue;
-                    }
                 }
                 int32_t parseDistance = pos.getIndex() - oldPos;
                 if (parseDistance > longestParseDistance) {
                     if (pattern->getArgTypeCount() != 0) {
                         resultNumber = tmpNumber;
                         withNumberFormat = true;
                     } else {
                         withNumberFormat = false;
                     }
                     resultTimeUnit = i;
                     newPos = pos.getIndex();
                     longestParseDistance = parseDistance;
                     countOfLongestMatch = count;
                 }
             }
         }
     }
     /* After find the longest match, parse the number.
      * Result number could be null for the pattern without number pattern.
      * such as unit pattern in Arabic.
      * When result number is null, use plural rule to set the number.
      */
     if (withNumberFormat == false && longestParseDistance != 0) {
         // set the number using plurrual count
         if (0 == countOfLongestMatch->compare(PLURAL_COUNT_ZERO, 4)) {
-            resultNumber = 0;
+            resultNumber = Formattable(0.0);
         } else if (0 == countOfLongestMatch->compare(PLURAL_COUNT_ONE, 3)) {
-            resultNumber = 1;
+            resultNumber = Formattable(1.0);
         } else if (0 == countOfLongestMatch->compare(PLURAL_COUNT_TWO, 3)) {
-            resultNumber = 2;
+            resultNumber = Formattable(2.0);
         } else {
             // should not happen.
             // TODO: how to handle?
-            resultNumber = 3;
+            resultNumber = Formattable(3.0);
         }
     }
     if (longestParseDistance == 0) {
         pos.setIndex(oldPos);
         pos.setErrorIndex(0);
     } else {
         UErrorCode status = U_ZERO_ERROR;
         TimeUnitAmount* tmutamt = new TimeUnitAmount(resultNumber, resultTimeUnit, status);
         if (U_SUCCESS(status)) {
             result.adoptObject(tmutamt);
             pos.setIndex(newPos);
             pos.setErrorIndex(-1);
         } else {
             pos.setIndex(oldPos);
             pos.setErrorIndex(0);
         }
     }
 }
 
 void
-TimeUnitFormat::create(const Locale& locale, UTimeUnitFormatStyle style, UErrorCode& status) {
+TimeUnitFormat::create(UTimeUnitFormatStyle style, UErrorCode& status) {
+    // fTimeUnitToCountToPatterns[] must have its elements initialized to NULL first
+    // before checking for failure status.
+    for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
+         i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
+         i = (TimeUnit::UTimeUnitFields)(i+1)) {
+        fTimeUnitToCountToPatterns[i] = NULL;
+    }
+
     if (U_FAILURE(status)) {
         return;
     }
     if (style < UTMUTFMT_FULL_STYLE || style >= UTMUTFMT_FORMAT_STYLE_COUNT) {
         status = U_ILLEGAL_ARGUMENT_ERROR;
         return;
     }
     fStyle = style;
-    fLocale = locale;
-    for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
-         i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
-         i = (TimeUnit::UTimeUnitFields)(i+1)) {
-        fTimeUnitToCountToPatterns[i] = NULL;
-    }
+
     //TODO: format() and parseObj() are const member functions,
     //so, can not do lazy initialization in C++.
     //setup has to be done in constructors.
     //and here, the behavior is not consistent with Java.
     //In Java, create an empty instance does not setup locale as
     //default locale. If it followed by setNumberFormat(),
     //in format(), the locale will set up as the locale in fNumberFormat.
     //But in C++, this sets the locale as the default locale. 
     setup(status);
 }
 
 void 
 TimeUnitFormat::setup(UErrorCode& err) {
     initDataMembers(err);
 
     UVector pluralCounts(0, uhash_compareUnicodeString, 6, err);
-    StringEnumeration* keywords = fPluralRules->getKeywords(err);
+    StringEnumeration* keywords = getPluralRules().getKeywords(err);
     if (U_FAILURE(err)) {
         return;
     }
     UnicodeString* pluralCount;
     while ((pluralCount = const_cast<UnicodeString*>(keywords->snext(err))) != NULL) {
       pluralCounts.addElement(pluralCount, err);
     }
     readFromCurrentLocale(UTMUTFMT_FULL_STYLE, gUnitsTag, pluralCounts, err);
     checkConsistency(UTMUTFMT_FULL_STYLE, gUnitsTag, err);
     readFromCurrentLocale(UTMUTFMT_ABBREVIATED_STYLE, gShortUnitsTag, pluralCounts, err);
     checkConsistency(UTMUTFMT_ABBREVIATED_STYLE, gShortUnitsTag, err);
     delete keywords;
 }
 
 
 void
 TimeUnitFormat::initDataMembers(UErrorCode& err){
     if (U_FAILURE(err)) {
         return;
     }
-    if (fNumberFormat == NULL) {
-        fNumberFormat = NumberFormat::createInstance(fLocale, err);
-    }
-    delete fPluralRules;
-    fPluralRules = PluralRules::forLocale(fLocale, err);
     for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
          i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
          i = (TimeUnit::UTimeUnitFields)(i+1)) {
         deleteHash(fTimeUnitToCountToPatterns[i]);
         fTimeUnitToCountToPatterns[i] = NULL;
     }
 }
 
 void
 TimeUnitFormat::readFromCurrentLocale(UTimeUnitFormatStyle style, const char* key,
                                       const UVector& pluralCounts, UErrorCode& err) {
     if (U_FAILURE(err)) {
         return;
     }
     // fill timeUnitToCountToPatterns from resource file
     // err is used to indicate wrong status except missing resource.
     // status is an error code used in resource lookup.
     // status does not affect "err".
     UErrorCode status = U_ZERO_ERROR;
     UResourceBundle *rb, *unitsRes;
-    rb = ures_open(NULL, fLocale.getName(), &status);
+    rb = ures_open(U_ICUDATA_UNIT, getLocaleID(status), &status);
     unitsRes = ures_getByKey(rb, key, NULL, &status);
     unitsRes = ures_getByKey(unitsRes, "duration", unitsRes, &status);
     if (U_FAILURE(status)) {
         ures_close(unitsRes);
         ures_close(rb);
         return;
     }
     int32_t size = ures_getSize(unitsRes);
     for ( int32_t index = 0; index < size; ++index) {
         // resource of one time unit
@@ skipping 49 matching lines @@
                 // resource of count to pattern
                 UnicodeString pattern =
                     ures_getNextUnicodeString(countsToPatternRB, &pluralCount, &status);
                 if (U_FAILURE(status)) {
                     continue;
                 }
                 UnicodeString pluralCountUniStr(pluralCount, -1, US_INV);
                 if (!pluralCounts.contains(&pluralCountUniStr)) {
                   continue;
                 }
-                MessageFormat* messageFormat = new MessageFormat(pattern, fLocale, err);
+                MessageFormat* messageFormat = new MessageFormat(pattern, getLocale(err), err);
                 if ( U_SUCCESS(err) ) {
-                  if (fNumberFormat != NULL) {
-                    messageFormat->setFormat(0, *fNumberFormat);
-                  }
                   MessageFormat** formatters = (MessageFormat**)countToPatterns->get(pluralCountUniStr);
                   if (formatters == NULL) {
                     formatters = (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*));
                     formatters[UTMUTFMT_FULL_STYLE] = NULL;
                     formatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL;
                     countToPatterns->put(pluralCountUniStr, formatters, err);
                     if (U_FAILURE(err)) {
                         uprv_free(formatters);
                     }
                   } 
@@ skipping 40 matching lines @@
     //         if the pattern is not found in root either,
     //         fallback to plural count "other",
     //         look for the pattern of "other" in the locale tree:
     //         "de_DE" to "de" to "root".
     //         If not found, fall back to value of 
     //         static variable DEFAULT_PATTERN_FOR_xxx, such as "{0} h". 
     //
     // Following is consistency check to create pattern for each
     // plural rule in each time unit using above fall-back rule.
     //
-    StringEnumeration* keywords = fPluralRules->getKeywords(err);
+    StringEnumeration* keywords = getPluralRules().getKeywords(err);
     if (U_SUCCESS(err)) {
         const UnicodeString* pluralCount;
         while ((pluralCount = keywords->snext(err)) != NULL) {
             if ( U_SUCCESS(err) ) {
                 for (int32_t i = 0; i < TimeUnit::UTIMEUNIT_FIELD_COUNT; ++i) {
                     // for each time unit, 
                     // get all the patterns for each plural rule in this locale.
                     Hashtable* countToPatterns = fTimeUnitToCountToPatterns[i];
                     if ( countToPatterns == NULL ) {
                         countToPatterns = initHash(err);
                         if (U_FAILURE(err)) {
                             delete countToPatterns;
                             return;
                         }
                         fTimeUnitToCountToPatterns[i] = countToPatterns;
                     }
                     MessageFormat** formatters = (MessageFormat**)countToPatterns->get(*pluralCount);
                     if( formatters == NULL || formatters[style] == NULL ) {
                         // look through parents
-                        const char* localeName = fLocale.getName();
+                        const char* localeName = getLocaleID(err);
                         CharString pluralCountChars;
                         pluralCountChars.appendInvariantChars(*pluralCount, err);
                         searchInLocaleChain(style, key, localeName,
                                             (TimeUnit::UTimeUnitFields)i, 
                                             *pluralCount, pluralCountChars.data(), 
                                             countToPatterns, err);
                     }
                 }
             }
         }
@@ skipping 23 matching lines @@
     }
     UErrorCode status = U_ZERO_ERROR;
     char parentLocale[ULOC_FULLNAME_CAPACITY];
     uprv_strcpy(parentLocale, localeName);
     int32_t locNameLen;
     U_ASSERT(countToPatterns != NULL);
     while ((locNameLen = uloc_getParent(parentLocale, parentLocale,
                                         ULOC_FULLNAME_CAPACITY, &status)) >= 0){
         // look for pattern for srcPluralCount in locale tree
         UResourceBundle *rb, *unitsRes, *countsToPatternRB;
-        rb = ures_open(NULL, parentLocale, &status);
+        rb = ures_open(U_ICUDATA_UNIT, parentLocale, &status);
         unitsRes = ures_getByKey(rb, key, NULL, &status);
         const char* timeUnitName = getTimeUnitName(srcTimeUnitField, status);
         countsToPatternRB = ures_getByKey(unitsRes, timeUnitName, NULL, &status);
         const UChar* pattern;
         int32_t      ptLength;
         pattern = ures_getStringByKeyWithFallback(countsToPatternRB, searchPluralCount, &ptLength, &status);
         if (U_SUCCESS(status)) {
             //found
-            MessageFormat* messageFormat = new MessageFormat(UnicodeString(TRUE, pattern, ptLength), fLocale, err);
+            MessageFormat* messageFormat = new MessageFormat(UnicodeString(TRUE, pattern, ptLength), getLocale(err), err);
             if (U_SUCCESS(err)) {
-                if (fNumberFormat != NULL) {
-                    messageFormat->setFormat(0, *fNumberFormat);
-                }
                 MessageFormat** formatters = (MessageFormat**)countToPatterns->get(srcPluralCount);
                 if (formatters == NULL) {
                     formatters = (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*));
                     formatters[UTMUTFMT_FULL_STYLE] = NULL;
                     formatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL;
                     countToPatterns->put(srcPluralCount, formatters, err);
                     if (U_FAILURE(err)) {
                         uprv_free(formatters);
                         delete messageFormat;
                     }
@@ skipping 53 matching lines @@
         } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_WEEK ) {
             pattern = DEFAULT_PATTERN_FOR_WEEK;
         } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_DAY ) {
             pattern = DEFAULT_PATTERN_FOR_DAY;
         } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_MONTH ) {
             pattern = DEFAULT_PATTERN_FOR_MONTH;
         } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_YEAR ) {
             pattern = DEFAULT_PATTERN_FOR_YEAR;
         }
         if (pattern != NULL) {
-            messageFormat = new MessageFormat(UnicodeString(TRUE, pattern, -1), fLocale, err);
+            messageFormat = new MessageFormat(UnicodeString(TRUE, pattern, -1), getLocale(err), err);
         }
         if (U_SUCCESS(err)) {
-            if (fNumberFormat != NULL && messageFormat != NULL) {
-                messageFormat->setFormat(0, *fNumberFormat);
-            }
             MessageFormat** formatters = (MessageFormat**)countToPatterns->get(srcPluralCount);
             if (formatters == NULL) {
                 formatters = (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*));
                 formatters[UTMUTFMT_FULL_STYLE] = NULL;
                 formatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL;
                 countToPatterns->put(srcPluralCount, formatters, err);
                 if (U_FAILURE(err)) {
                     uprv_free(formatters);
                     delete messageFormat;
                 }
             }
             if (U_SUCCESS(err)) {
                 //delete formatters[style];
                 formatters[style] = messageFormat;
             }
         } else {
             delete messageFormat;
         }
     } else {
         // fall back to rule "other", and search in parents
         searchInLocaleChain(style, key, localeName, srcTimeUnitField, srcPluralCount, 
                             gPluralCountOther, countToPatterns, err);
     }
 }
 
 void 
 TimeUnitFormat::setLocale(const Locale& locale, UErrorCode& status) {
-    if (U_SUCCESS(status) && fLocale != locale) {
-        fLocale = locale;
+    if (setMeasureFormatLocale(locale, status)) {
         setup(status);
     }
 }
 
 
 void 
 TimeUnitFormat::setNumberFormat(const NumberFormat& format, UErrorCode& status){
-    if (U_FAILURE(status) || (fNumberFormat && format == *fNumberFormat)) {
+    if (U_FAILURE(status)) {
         return;
     }
-    delete fNumberFormat;
-    fNumberFormat = (NumberFormat*)format.clone();
-    // reset the number formatter in the fTimeUnitToCountToPatterns map
-    for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
-         i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
-         i = (TimeUnit::UTimeUnitFields)(i+1)) {
-        int32_t pos = -1;
-        const UHashElement* elem = NULL;
-        while ((elem = fTimeUnitToCountToPatterns[i]->nextElement(pos)) != NULL){
-            const UHashTok keyTok = elem->value;
-            MessageFormat** pattern = (MessageFormat**)keyTok.pointer;
-
-            pattern[UTMUTFMT_FULL_STYLE]->setFormat(0, format);
-            pattern[UTMUTFMT_ABBREVIATED_STYLE]->setFormat(0, format);
-        }
-    }
+    adoptNumberFormat((NumberFormat *)format.clone(), status);
 }
 
 
 void
 TimeUnitFormat::deleteHash(Hashtable* htable) {
     int32_t pos = -1;
     const UHashElement* element = NULL;
     if ( htable ) {
         while ( (element = htable->nextElement(pos)) != NULL ) {
             const UHashTok valueTok = element->value;
@@ skipping 98 matching lines @@
         return gTimeUnitSecond;
       default:
         status = U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;
     }
 }
 
 U_NAMESPACE_END
 
 #endif