ICU 56 update step 1

source/i18n/measfmt.cpp

 /*
 **********************************************************************
-* Copyright (c) 2004-2014, International Business Machines
+* Copyright (c) 2004-2015, International Business Machines
 * Corporation and others.  All Rights Reserved.
 **********************************************************************
 * Author: Alan Liu
 * Created: April 20, 2004
 * Since: ICU 3.0
 **********************************************************************
 */
 #include "utypeinfo.h"  // for 'typeid' to work
 #include "unicode/utypes.h"
 
@@ skipping 16 matching lines @@
 #include "unicode/listformatter.h"
 #include "charstr.h"
 #include "unicode/putil.h"
 #include "unicode/smpdtfmt.h"
 #include "uassert.h"
 
 #include "sharednumberformat.h"
 #include "sharedpluralrules.h"
 #include "unifiedcache.h"
 
-#define MEAS_UNIT_COUNT 121
+#define MEAS_UNIT_COUNT 129
 #define WIDTH_INDEX_COUNT (UMEASFMT_WIDTH_NARROW + 1)
 
 U_NAMESPACE_BEGIN
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(MeasureFormat)
 
 // Used to format durations like 5:47 or 21:35:42.
 class NumericDateFormatters : public UMemory {
 public:
     // Formats like H:mm
@@ skipping 288 matching lines @@
         delete result;
         return NULL;
     }
     return result;
 }
 
 template<> U_I18N_API
 const MeasureFormatCacheData *LocaleCacheKey<MeasureFormatCacheData>::createObject(
         const void * /*unused*/, UErrorCode &status) const {
     const char *localeId = fLoc.getName();
-    LocalUResourceBundlePointer topLevel(ures_open(NULL, localeId, &status));
     LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, localeId, &status));
     static UNumberFormatStyle currencyStyles[] = {
             UNUM_CURRENCY_PLURAL, UNUM_CURRENCY_ISO, UNUM_CURRENCY};
+    LocalPointer<MeasureFormatCacheData> result(new MeasureFormatCacheData(), status);
     if (U_FAILURE(status)) {
         return NULL;
     }
-    LocalPointer<MeasureFormatCacheData> result(new MeasureFormatCacheData());
-    if (result.isNull()) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-        return NULL;
-    }
     if (!loadMeasureUnitData(
             unitsBundle.getAlias(),
             *result,
             status)) {
         return NULL;
     }
     result->adoptNumericDateFormatters(loadNumericDateFormatters(
-            topLevel.getAlias(), status));
+            unitsBundle.getAlias(), status));
     if (U_FAILURE(status)) {
         return NULL;
     }
 
     for (int32_t i = 0; i < WIDTH_INDEX_COUNT; ++i) {
         result->adoptCurrencyFormat(i, NumberFormat::createInstance(
                 localeId, currencyStyles[i], status));
         if (U_FAILURE(status)) {
             return NULL;
         }
@@ skipping 126 matching lines @@
     width = other.width;
     delete listFormatter;
     listFormatter = new ListFormatter(*other.listFormatter);
     return *this;
 }
 
 MeasureFormat::MeasureFormat() :
         cache(NULL),
         numberFormat(NULL),
         pluralRules(NULL),
-        width(UMEASFMT_WIDTH_WIDE),
+        width(UMEASFMT_WIDTH_SHORT),
         listFormatter(NULL) {
 }
 
 MeasureFormat::~MeasureFormat() {
     if (cache != NULL) {
         cache->removeRef();
     }
     if (numberFormat != NULL) {
         numberFormat->removeRef();
     }
@@ skipping 61 matching lines @@
     return appendTo;
 }
 
 void MeasureFormat::parseObject(
         const UnicodeString & /*source*/,
         Formattable & /*result*/,
         ParsePosition& /*pos*/) const {
     return;
 }
 
-UnicodeString &MeasureFormat::formatMeasuresPer(
-        const Measure *measures,
-        int32_t measureCount,
+UnicodeString &MeasureFormat::formatMeasurePerUnit(
+        const Measure &measure,
         const MeasureUnit &perUnit,
         UnicodeString &appendTo,
         FieldPosition &pos,
         UErrorCode &status) const {
+    if (U_FAILURE(status)) {
+        return appendTo;
+    }
+    MeasureUnit *resolvedUnit =
+            MeasureUnit::resolveUnitPerUnit(measure.getUnit(), perUnit);
+    if (resolvedUnit != NULL) {
+        Measure newMeasure(measure.getNumber(), resolvedUnit, status);
+        return formatMeasure(
+                newMeasure, **numberFormat, appendTo, pos, status);
+    }
     FieldPosition fpos(pos.getField());
-    UnicodeString measuresString;
-    int32_t offset = withPerUnit(
-            formatMeasures(
-                    measures, measureCount, measuresString, fpos, status),
+    UnicodeString result;
+    int32_t offset = withPerUnitAndAppend(
+            formatMeasure(
+                    measure, **numberFormat, result, fpos, status),
             perUnit,
             appendTo,
             status);
     if (U_FAILURE(status)) {
         return appendTo;
     }
     if (fpos.getBeginIndex() != 0 || fpos.getEndIndex() != 0) {
         pos.setBeginIndex(fpos.getBeginIndex() + offset);
         pos.setEndIndex(fpos.getEndIndex() + offset);
     }
@@ skipping 305 matching lines @@
         return NULL;
     }
     const QuantityFormatter *formatters =
             cache->formatters[index];
     if (formatters[widthIndex].isValid()) {
         return &formatters[widthIndex];
     }
     if (formatters[UMEASFMT_WIDTH_SHORT].isValid()) {
         return &formatters[UMEASFMT_WIDTH_SHORT];
     }
-    if (formatters[UMEASFMT_WIDTH_WIDE].isValid()) {
-        return &formatters[UMEASFMT_WIDTH_WIDE];
-    }
     status = U_MISSING_RESOURCE_ERROR;
     return NULL;
 }
 
 const SimplePatternFormatter *MeasureFormat::getPerUnitFormatter(
         int32_t index,
         int32_t widthIndex) const {
     const SimplePatternFormatter * const * perUnitFormatters =
             cache->getPerUnitFormattersByIndex(index);
     if (perUnitFormatters[widthIndex] != NULL) {
         return perUnitFormatters[widthIndex];
     }
     if (perUnitFormatters[UMEASFMT_WIDTH_SHORT] != NULL) {
         return perUnitFormatters[UMEASFMT_WIDTH_SHORT];
     }
-    if (perUnitFormatters[UMEASFMT_WIDTH_WIDE] != NULL) {
-        return perUnitFormatters[UMEASFMT_WIDTH_WIDE];
-    }
     return NULL;
 }
 
 const SimplePatternFormatter *MeasureFormat::getPerFormatter(
         int32_t widthIndex,
         UErrorCode &status) const {
     if (U_FAILURE(status)) {
         return NULL;
     }
     const SimplePatternFormatter * perFormatters = cache->perFormatters;
     
     if (perFormatters[widthIndex].getPlaceholderCount() == 2) {
         return &perFormatters[widthIndex];
     }
     if (perFormatters[UMEASFMT_WIDTH_SHORT].getPlaceholderCount() == 2) {
         return &perFormatters[UMEASFMT_WIDTH_SHORT];
     }
-    if (perFormatters[UMEASFMT_WIDTH_WIDE].getPlaceholderCount() == 2) {
-        return &perFormatters[UMEASFMT_WIDTH_WIDE];
-    }
     status = U_MISSING_RESOURCE_ERROR;
     return NULL;
 }
 
 static void getPerUnitString(
         const QuantityFormatter &formatter,
         UnicodeString &result) {
     result = formatter.getByVariant("one")->getPatternWithNoPlaceholders();
     result.trim();
 }
 
-int32_t MeasureFormat::withPerUnit(
+int32_t MeasureFormat::withPerUnitAndAppend(
         const UnicodeString &formatted,
         const MeasureUnit &perUnit,
         UnicodeString &appendTo,
         UErrorCode &status) const {
     int32_t offset = -1;
     if (U_FAILURE(status)) {
         return offset;
     }
     const SimplePatternFormatter *perUnitFormatter = getPerUnitFormatter(
             perUnit.getIndex(), widthToIndex(width));
     if (perUnitFormatter != NULL) {
         const UnicodeString *params[] = {&formatted};
-        perUnitFormatter->format(
+        perUnitFormatter->formatAndAppend(
                 params,
                 UPRV_LENGTHOF(params),
                 appendTo,
                 &offset,
                 1,
                 status);
         return offset;
     }
     const SimplePatternFormatter *perFormatter = getPerFormatter(
             widthToIndex(width), status);
     const QuantityFormatter *qf = getQuantityFormatter(
             perUnit.getIndex(), widthToIndex(width), status);
     if (U_FAILURE(status)) {
         return offset;
     }
     UnicodeString perUnitString;
     getPerUnitString(*qf, perUnitString);
     const UnicodeString *params[] = {&formatted, &perUnitString};
-    perFormatter->format(
+    perFormatter->formatAndAppend(
             params,
             UPRV_LENGTHOF(params),
             appendTo,
             &offset,
             1,
             status);
     return offset;
 }
 
 UnicodeString &MeasureFormat::formatMeasuresSlowTrack(
@@ skipping 63 matching lines @@
 MeasureFormat* U_EXPORT2 MeasureFormat::createCurrencyFormat(UErrorCode& ec) {
     if (U_FAILURE(ec)) {
         return NULL;
     }
     return MeasureFormat::createCurrencyFormat(Locale::getDefault(), ec);
 }
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_FORMATTING */