/* ********************************************************************** * Copyright (c) 2004-2014, 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" #if !UCONFIG_NO_FORMATTING #include "unicode/measfmt.h" #include "unicode/numfmt.h" #include "currfmt.h" #include "unicode/localpointer.h" #include "quantityformatter.h" #include "unicode/plurrule.h" #include "unicode/decimfmt.h" #include "lrucache.h" #include "uresimp.h" #include "unicode/ures.h" #include "cstring.h" #include "mutex.h" #include "ucln_in.h" #include "unicode/listformatter.h" #include "charstr.h" #include "unicode/putil.h" #include "unicode/smpdtfmt.h" #include "sharednumberformat.h" #include "sharedpluralrules.h" #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) #define MEAS_UNIT_COUNT 46 #define WIDTH_INDEX_COUNT (UMEASFMT_WIDTH_NARROW + 1) static icu::LRUCache *gCache = NULL; static UMutex gCacheMutex = U_MUTEX_INITIALIZER; static icu::UInitOnce gCacheInitOnce = U_INITONCE_INITIALIZER; U_CDECL_BEGIN static UBool U_CALLCONV measfmt_cleanup() { gCacheInitOnce.reset(); if (gCache) { delete gCache; gCache = NULL; } return TRUE; } U_CDECL_END 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 SimpleDateFormat hourMinute; // formats like M:ss SimpleDateFormat minuteSecond; // formats like H:mm:ss SimpleDateFormat hourMinuteSecond; // Constructor that takes the actual patterns for hour-minute, // minute-second, and hour-minute-second respectively. NumericDateFormatters( const UnicodeString &hm, const UnicodeString &ms, const UnicodeString &hms, UErrorCode &status) : hourMinute(hm, status), minuteSecond(ms, status), hourMinuteSecond(hms, status) { const TimeZone *gmt = TimeZone::getGMT(); hourMinute.setTimeZone(*gmt); minuteSecond.setTimeZone(*gmt); hourMinuteSecond.setTimeZone(*gmt); } private: NumericDateFormatters(const NumericDateFormatters &other); NumericDateFormatters &operator=(const NumericDateFormatters &other); }; // Instances contain all MeasureFormat specific data for a particular locale. // This data is cached. It is never copied, but is shared via shared pointers. class MeasureFormatCacheData : public SharedObject { public: QuantityFormatter formatters[MEAS_UNIT_COUNT][WIDTH_INDEX_COUNT]; MeasureFormatCacheData(); void adoptCurrencyFormat(int32_t widthIndex, NumberFormat *nfToAdopt) { delete currencyFormats[widthIndex]; currencyFormats[widthIndex] = nfToAdopt; } const NumberFormat *getCurrencyFormat(int32_t widthIndex) const { return currencyFormats[widthIndex]; } void adoptIntegerFormat(NumberFormat *nfToAdopt) { delete integerFormat; integerFormat = nfToAdopt; } const NumberFormat *getIntegerFormat() const { return integerFormat; } void adoptNumericDateFormatters(NumericDateFormatters *formattersToAdopt) { delete numericDateFormatters; numericDateFormatters = formattersToAdopt; } const NumericDateFormatters *getNumericDateFormatters() const { return numericDateFormatters; } virtual ~MeasureFormatCacheData(); private: NumberFormat *currencyFormats[WIDTH_INDEX_COUNT]; NumberFormat *integerFormat; NumericDateFormatters *numericDateFormatters; MeasureFormatCacheData(const MeasureFormatCacheData &other); MeasureFormatCacheData &operator=(const MeasureFormatCacheData &other); }; MeasureFormatCacheData::MeasureFormatCacheData() { for (int32_t i = 0; i < LENGTHOF(currencyFormats); ++i) { currencyFormats[i] = NULL; } integerFormat = NULL; numericDateFormatters = NULL; } MeasureFormatCacheData::~MeasureFormatCacheData() { for (int32_t i = 0; i < LENGTHOF(currencyFormats); ++i) { delete currencyFormats[i]; } delete integerFormat; delete numericDateFormatters; } static int32_t widthToIndex(UMeasureFormatWidth width) { if (width >= WIDTH_INDEX_COUNT) { return WIDTH_INDEX_COUNT - 1; } return width; } static UBool isCurrency(const MeasureUnit &unit) { return (uprv_strcmp(unit.getType(), "currency") == 0); } static UBool getString( const UResourceBundle *resource, UnicodeString &result, UErrorCode &status) { int32_t len = 0; const UChar *resStr = ures_getString(resource, &len, &status); if (U_FAILURE(status)) { return FALSE; } result.setTo(TRUE, resStr, len); return TRUE; } static UBool loadMeasureUnitData( const UResourceBundle *resource, MeasureFormatCacheData &cacheData, UErrorCode &status) { if (U_FAILURE(status)) { return FALSE; } static const char *widthPath[] = {"units", "unitsShort", "unitsNarrow"}; MeasureUnit *units = NULL; int32_t unitCount = MeasureUnit::getAvailable(units, 0, status); while (status == U_BUFFER_OVERFLOW_ERROR) { status = U_ZERO_ERROR; delete [] units; units = new MeasureUnit[unitCount]; if (units == NULL) { status = U_MEMORY_ALLOCATION_ERROR; return FALSE; } unitCount = MeasureUnit::getAvailable(units, unitCount, status); } for (int32_t currentWidth = 0; currentWidth < WIDTH_INDEX_COUNT; ++currentWidth) { // Be sure status is clear since next resource bundle lookup may fail. if (U_FAILURE(status)) { delete [] units; return FALSE; } LocalUResourceBundlePointer widthBundle( ures_getByKeyWithFallback( resource, widthPath[currentWidth], NULL, &status)); // We may not have data for all widths in all locales. if (status == U_MISSING_RESOURCE_ERROR) { status = U_ZERO_ERROR; continue; } for (int32_t currentUnit = 0; currentUnit < unitCount; ++currentUnit) { // Be sure status is clear next lookup may fail. if (U_FAILURE(status)) { delete [] units; return FALSE; } if (isCurrency(units[currentUnit])) { continue; } CharString pathBuffer; pathBuffer.append(units[currentUnit].getType(), status) .append("/", status) .append(units[currentUnit].getSubtype(), status); LocalUResourceBundlePointer unitBundle( ures_getByKeyWithFallback( widthBundle.getAlias(), pathBuffer.data(), NULL, &status)); // We may not have data for all units in all widths if (status == U_MISSING_RESOURCE_ERROR) { status = U_ZERO_ERROR; continue; } // We must have the unit bundle to proceed if (U_FAILURE(status)) { delete [] units; return FALSE; } int32_t size = ures_getSize(unitBundle.getAlias()); for (int32_t plIndex = 0; plIndex < size; ++plIndex) { LocalUResourceBundlePointer pluralBundle( ures_getByIndex( unitBundle.getAlias(), plIndex, NULL, &status)); if (U_FAILURE(status)) { delete [] units; return FALSE; } UnicodeString rawPattern; getString(pluralBundle.getAlias(), rawPattern, status); cacheData.formatters[units[currentUnit].getIndex()][currentWidth].add( ures_getKey(pluralBundle.getAlias()), rawPattern, status); } } } delete [] units; return U_SUCCESS(status); } static UnicodeString loadNumericDateFormatterPattern( const UResourceBundle *resource, const char *pattern, UErrorCode &status) { UnicodeString result; if (U_FAILURE(status)) { return result; } CharString chs; chs.append("durationUnits", status) .append("/", status).append(pattern, status); LocalUResourceBundlePointer patternBundle( ures_getByKeyWithFallback( resource, chs.data(), NULL, &status)); if (U_FAILURE(status)) { return result; } getString(patternBundle.getAlias(), result, status); // Replace 'h' with 'H' int32_t len = result.length(); UChar *buffer = result.getBuffer(len); for (int32_t i = 0; i < len; ++i) { if (buffer[i] == 0x68) { // 'h' buffer[i] = 0x48; // 'H' } } result.releaseBuffer(len); return result; } static NumericDateFormatters *loadNumericDateFormatters( const UResourceBundle *resource, UErrorCode &status) { if (U_FAILURE(status)) { return NULL; } NumericDateFormatters *result = new NumericDateFormatters( loadNumericDateFormatterPattern(resource, "hm", status), loadNumericDateFormatterPattern(resource, "ms", status), loadNumericDateFormatterPattern(resource, "hms", status), status); if (U_FAILURE(status)) { delete result; return NULL; } return result; } // Creates the MeasureFormatCacheData for a particular locale static SharedObject *U_CALLCONV createData( const char *localeId, UErrorCode &status) { LocalUResourceBundlePointer topLevel(ures_open(NULL, localeId, &status)); static UNumberFormatStyle currencyStyles[] = { UNUM_CURRENCY_PLURAL, UNUM_CURRENCY_ISO, UNUM_CURRENCY}; if (U_FAILURE(status)) { return NULL; } LocalPointer result(new MeasureFormatCacheData()); if (result.isNull()) { status = U_MEMORY_ALLOCATION_ERROR; return NULL; } if (!loadMeasureUnitData( topLevel.getAlias(), *result, status)) { return NULL; } result->adoptNumericDateFormatters(loadNumericDateFormatters( topLevel.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; } } NumberFormat *inf = NumberFormat::createInstance( localeId, UNUM_DECIMAL, status); if (U_FAILURE(status)) { return NULL; } inf->setMaximumFractionDigits(0); DecimalFormat *decfmt = dynamic_cast(inf); if (decfmt != NULL) { decfmt->setRoundingMode(DecimalFormat::kRoundDown); } result->adoptIntegerFormat(inf); return result.orphan(); } static void U_CALLCONV cacheInit(UErrorCode &status) { U_ASSERT(gCache == NULL); U_ASSERT(MeasureUnit::getIndexCount() == MEAS_UNIT_COUNT); ucln_i18n_registerCleanup(UCLN_I18N_MEASFMT, measfmt_cleanup); gCache = new SimpleLRUCache(100, &createData, status); if (U_FAILURE(status)) { delete gCache; gCache = NULL; } } static UBool getFromCache( const char *locale, const MeasureFormatCacheData *&ptr, UErrorCode &status) { umtx_initOnce(gCacheInitOnce, &cacheInit, status); if (U_FAILURE(status)) { return FALSE; } Mutex lock(&gCacheMutex); gCache->get(locale, ptr, status); return U_SUCCESS(status); } static UBool isTimeUnit(const MeasureUnit &mu, const char *tu) { return uprv_strcmp(mu.getType(), "duration") == 0 && uprv_strcmp(mu.getSubtype(), tu) == 0; } // Converts a composite measure into hours-minutes-seconds and stores at hms // array. [0] is hours; [1] is minutes; [2] is seconds. Returns a bit map of // units found: 1=hours, 2=minutes, 4=seconds. For example, if measures // contains hours-minutes, this function would return 3. // // If measures cannot be converted into hours, minutes, seconds or if amounts // are negative, or if hours, minutes, seconds are out of order, returns 0. static int32_t toHMS( const Measure *measures, int32_t measureCount, Formattable *hms, UErrorCode &status) { if (U_FAILURE(status)) { return 0; } int32_t result = 0; if (U_FAILURE(status)) { return 0; } // We use copy constructor to ensure that both sides of equality operator // are instances of MeasureUnit base class and not a subclass. Otherwise, // operator== will immediately return false. // TODO(Travis Keep): Propose // UBool isUnitSame(const MeasureUnit &other) const to address performance // issues around copy constructor. for (int32_t i = 0; i < measureCount; ++i) { if (isTimeUnit(measures[i].getUnit(), "hour")) { // hour must come first if (result >= 1) { return 0; } hms[0] = measures[i].getNumber(); if (hms[0].getDouble() < 0.0) { return 0; } result |= 1; } else if (isTimeUnit(measures[i].getUnit(), "minute")) { // minute must come after hour if (result >= 2) { return 0; } hms[1] = measures[i].getNumber(); if (hms[1].getDouble() < 0.0) { return 0; } result |= 2; } else if (isTimeUnit(measures[i].getUnit(), "second")) { // second must come after hour and minute if (result >= 4) { return 0; } hms[2] = measures[i].getNumber(); if (hms[2].getDouble() < 0.0) { return 0; } result |= 4; } else { return 0; } } return result; } MeasureFormat::MeasureFormat( const Locale &locale, UMeasureFormatWidth w, UErrorCode &status) : cache(NULL), numberFormat(NULL), pluralRules(NULL), width(w), listFormatter(NULL) { initMeasureFormat(locale, w, NULL, status); } MeasureFormat::MeasureFormat( const Locale &locale, UMeasureFormatWidth w, NumberFormat *nfToAdopt, UErrorCode &status) : cache(NULL), numberFormat(NULL), pluralRules(NULL), width(w), listFormatter(NULL) { initMeasureFormat(locale, w, nfToAdopt, status); } MeasureFormat::MeasureFormat(const MeasureFormat &other) : Format(other), cache(other.cache), numberFormat(other.numberFormat), pluralRules(other.pluralRules), width(other.width), listFormatter(NULL) { cache->addRef(); numberFormat->addRef(); pluralRules->addRef(); listFormatter = new ListFormatter(*other.listFormatter); } MeasureFormat &MeasureFormat::operator=(const MeasureFormat &other) { if (this == &other) { return *this; } Format::operator=(other); SharedObject::copyPtr(other.cache, cache); SharedObject::copyPtr(other.numberFormat, numberFormat); SharedObject::copyPtr(other.pluralRules, pluralRules); width = other.width; delete listFormatter; listFormatter = new ListFormatter(*other.listFormatter); return *this; } MeasureFormat::MeasureFormat() : cache(NULL), numberFormat(NULL), pluralRules(NULL), width(UMEASFMT_WIDTH_WIDE), listFormatter(NULL) { } MeasureFormat::~MeasureFormat() { if (cache != NULL) { cache->removeRef(); } if (numberFormat != NULL) { numberFormat->removeRef(); } if (pluralRules != NULL) { pluralRules->removeRef(); } delete listFormatter; } UBool MeasureFormat::operator==(const Format &other) const { if (this == &other) { // Same object, equal return TRUE; } if (!Format::operator==(other)) { return FALSE; } const MeasureFormat &rhs = static_cast(other); // Note: Since the ListFormatter depends only on Locale and width, we // don't have to check it here. // differing widths aren't equivalent if (width != rhs.width) { return FALSE; } // Width the same check locales. // We don't need to check locales if both objects have same cache. if (cache != rhs.cache) { UErrorCode status = U_ZERO_ERROR; const char *localeId = getLocaleID(status); const char *rhsLocaleId = rhs.getLocaleID(status); if (U_FAILURE(status)) { // On failure, assume not equal return FALSE; } if (uprv_strcmp(localeId, rhsLocaleId) != 0) { return FALSE; } } // Locales same, check NumberFormat if shared data differs. return ( numberFormat == rhs.numberFormat || **numberFormat == **rhs.numberFormat); } Format *MeasureFormat::clone() const { return new MeasureFormat(*this); } UnicodeString &MeasureFormat::format( const Formattable &obj, UnicodeString &appendTo, FieldPosition &pos, UErrorCode &status) const { if (U_FAILURE(status)) return appendTo; if (obj.getType() == Formattable::kObject) { const UObject* formatObj = obj.getObject(); const Measure* amount = dynamic_cast(formatObj); if (amount != NULL) { return formatMeasure( *amount, **numberFormat, appendTo, pos, status); } } status = U_ILLEGAL_ARGUMENT_ERROR; return appendTo; } void MeasureFormat::parseObject( const UnicodeString & /*source*/, Formattable & /*result*/, ParsePosition& /*pos*/) const { return; } UnicodeString &MeasureFormat::formatMeasures( const Measure *measures, int32_t measureCount, UnicodeString &appendTo, FieldPosition &pos, UErrorCode &status) const { if (U_FAILURE(status)) { return appendTo; } if (measureCount == 0) { return appendTo; } if (measureCount == 1) { return formatMeasure(measures[0], **numberFormat, appendTo, pos, status); } if (width == UMEASFMT_WIDTH_NUMERIC) { Formattable hms[3]; int32_t bitMap = toHMS(measures, measureCount, hms, status); if (bitMap > 0) { return formatNumeric(hms, bitMap, appendTo, status); } } if (pos.getField() != FieldPosition::DONT_CARE) { return formatMeasuresSlowTrack( measures, measureCount, appendTo, pos, status); } UnicodeString *results = new UnicodeString[measureCount]; if (results == NULL) { status = U_MEMORY_ALLOCATION_ERROR; return appendTo; } for (int32_t i = 0; i < measureCount; ++i) { const NumberFormat *nf = cache->getIntegerFormat(); if (i == measureCount - 1) { nf = numberFormat->get(); } formatMeasure( measures[i], *nf, results[i], pos, status); } listFormatter->format(results, measureCount, appendTo, status); delete [] results; return appendTo; } void MeasureFormat::initMeasureFormat( const Locale &locale, UMeasureFormatWidth w, NumberFormat *nfToAdopt, UErrorCode &status) { static const char *listStyles[] = {"unit", "unit-short", "unit-narrow"}; LocalPointer nf(nfToAdopt); if (U_FAILURE(status)) { return; } const char *name = locale.getName(); setLocaleIDs(name, name); if (!getFromCache(name, cache, status)) { return; } SharedObject::copyPtr( PluralRules::createSharedInstance( locale, UPLURAL_TYPE_CARDINAL, status), pluralRules); if (U_FAILURE(status)) { return; } pluralRules->removeRef(); if (nf.isNull()) { SharedObject::copyPtr( NumberFormat::createSharedInstance( locale, UNUM_DECIMAL, status), numberFormat); if (U_FAILURE(status)) { return; } numberFormat->removeRef(); } else { adoptNumberFormat(nf.orphan(), status); if (U_FAILURE(status)) { return; } } width = w; delete listFormatter; listFormatter = ListFormatter::createInstance( locale, listStyles[widthToIndex(width)], status); } void MeasureFormat::adoptNumberFormat( NumberFormat *nfToAdopt, UErrorCode &status) { LocalPointer nf(nfToAdopt); if (U_FAILURE(status)) { return; } SharedNumberFormat *shared = new SharedNumberFormat(nf.getAlias()); if (shared == NULL) { status = U_MEMORY_ALLOCATION_ERROR; return; } nf.orphan(); SharedObject::copyPtr(shared, numberFormat); } UBool MeasureFormat::setMeasureFormatLocale(const Locale &locale, UErrorCode &status) { if (U_FAILURE(status) || locale == getLocale(status)) { return FALSE; } initMeasureFormat(locale, width, NULL, status); return U_SUCCESS(status); } const NumberFormat &MeasureFormat::getNumberFormat() const { return **numberFormat; } const PluralRules &MeasureFormat::getPluralRules() const { return **pluralRules; } Locale MeasureFormat::getLocale(UErrorCode &status) const { return Format::getLocale(ULOC_VALID_LOCALE, status); } const char *MeasureFormat::getLocaleID(UErrorCode &status) const { return Format::getLocaleID(ULOC_VALID_LOCALE, status); } UnicodeString &MeasureFormat::formatMeasure( const Measure &measure, const NumberFormat &nf, UnicodeString &appendTo, FieldPosition &pos, UErrorCode &status) const { if (U_FAILURE(status)) { return appendTo; } const Formattable& amtNumber = measure.getNumber(); const MeasureUnit& amtUnit = measure.getUnit(); if (isCurrency(amtUnit)) { UChar isoCode[4]; u_charsToUChars(amtUnit.getSubtype(), isoCode, 4); return cache->getCurrencyFormat(widthToIndex(width))->format( new CurrencyAmount(amtNumber, isoCode, status), appendTo, pos, status); } const QuantityFormatter *quantityFormatter = getQuantityFormatter( amtUnit.getIndex(), widthToIndex(width), status); if (U_FAILURE(status)) { return appendTo; } return quantityFormatter->format( amtNumber, nf, **pluralRules, appendTo, pos, status); } // Formats hours-minutes-seconds as 5:37:23 or similar. UnicodeString &MeasureFormat::formatNumeric( const Formattable *hms, // always length 3 int32_t bitMap, // 1=hourset, 2=minuteset, 4=secondset UnicodeString &appendTo, UErrorCode &status) const { if (U_FAILURE(status)) { return appendTo; } UDate millis = (UDate) (((uprv_trunc(hms[0].getDouble(status)) * 60.0 + uprv_trunc(hms[1].getDouble(status))) * 60.0 + uprv_trunc(hms[2].getDouble(status))) * 1000.0); switch (bitMap) { case 5: // hs case 7: // hms return formatNumeric( millis, cache->getNumericDateFormatters()->hourMinuteSecond, UDAT_SECOND_FIELD, hms[2], appendTo, status); break; case 6: // ms return formatNumeric( millis, cache->getNumericDateFormatters()->minuteSecond, UDAT_SECOND_FIELD, hms[2], appendTo, status); break; case 3: // hm return formatNumeric( millis, cache->getNumericDateFormatters()->hourMinute, UDAT_MINUTE_FIELD, hms[1], appendTo, status); break; default: status = U_INTERNAL_PROGRAM_ERROR; return appendTo; break; } return appendTo; } static void appendRange( const UnicodeString &src, int32_t start, int32_t end, UnicodeString &dest) { dest.append(src, start, end - start); } static void appendRange( const UnicodeString &src, int32_t end, UnicodeString &dest) { dest.append(src, end, src.length() - end); } // Formats time like 5:37:23 UnicodeString &MeasureFormat::formatNumeric( UDate date, // Time since epoch 1:30:00 would be 5400000 const DateFormat &dateFmt, // h:mm, m:ss, or h:mm:ss UDateFormatField smallestField, // seconds in 5:37:23.5 const Formattable &smallestAmount, // 23.5 for 5:37:23.5 UnicodeString &appendTo, UErrorCode &status) const { if (U_FAILURE(status)) { return appendTo; } // Format the smallest amount with this object's NumberFormat UnicodeString smallestAmountFormatted; // We keep track of the integer part of smallest amount so that // we can replace it later so that we get '0:00:09.3' instead of // '0:00:9.3' FieldPosition intFieldPosition(UNUM_INTEGER_FIELD); (*numberFormat)->format( smallestAmount, smallestAmountFormatted, intFieldPosition, status); if ( intFieldPosition.getBeginIndex() == 0 && intFieldPosition.getEndIndex() == 0) { status = U_INTERNAL_PROGRAM_ERROR; return appendTo; } // Format time. draft becomes something like '5:30:45' FieldPosition smallestFieldPosition(smallestField); UnicodeString draft; dateFmt.format(date, draft, smallestFieldPosition, status); // If we find field for smallest amount replace it with the formatted // smallest amount from above taking care to replace the integer part // with what is in original time. For example, If smallest amount // is 9.35s and the formatted time is 0:00:09 then 9.35 becomes 09.35 // and replacing yields 0:00:09.35 if (smallestFieldPosition.getBeginIndex() != 0 || smallestFieldPosition.getEndIndex() != 0) { appendRange(draft, 0, smallestFieldPosition.getBeginIndex(), appendTo); appendRange( smallestAmountFormatted, 0, intFieldPosition.getBeginIndex(), appendTo); appendRange( draft, smallestFieldPosition.getBeginIndex(), smallestFieldPosition.getEndIndex(), appendTo); appendRange( smallestAmountFormatted, intFieldPosition.getEndIndex(), appendTo); appendRange( draft, smallestFieldPosition.getEndIndex(), appendTo); } else { appendTo.append(draft); } return appendTo; } const QuantityFormatter *MeasureFormat::getQuantityFormatter( int32_t index, int32_t widthIndex, UErrorCode &status) const { if (U_FAILURE(status)) { 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; } UnicodeString &MeasureFormat::formatMeasuresSlowTrack( const Measure *measures, int32_t measureCount, UnicodeString& appendTo, FieldPosition& pos, UErrorCode& status) const { if (U_FAILURE(status)) { return appendTo; } FieldPosition dontCare(FieldPosition::DONT_CARE); FieldPosition fpos(pos.getField()); UnicodeString *results = new UnicodeString[measureCount]; int32_t fieldPositionFoundIndex = -1; for (int32_t i = 0; i < measureCount; ++i) { const NumberFormat *nf = cache->getIntegerFormat(); if (i == measureCount - 1) { nf = numberFormat->get(); } if (fieldPositionFoundIndex == -1) { formatMeasure(measures[i], *nf, results[i], fpos, status); if (U_FAILURE(status)) { delete [] results; return appendTo; } if (fpos.getBeginIndex() != 0 || fpos.getEndIndex() != 0) { fieldPositionFoundIndex = i; } } else { formatMeasure(measures[i], *nf, results[i], dontCare, status); } } int32_t offset; listFormatter->format( results, measureCount, appendTo, fieldPositionFoundIndex, offset, status); if (U_FAILURE(status)) { delete [] results; return appendTo; } if (offset != -1) { pos.setBeginIndex(fpos.getBeginIndex() + offset); pos.setEndIndex(fpos.getEndIndex() + offset); } delete [] results; return appendTo; } MeasureFormat* U_EXPORT2 MeasureFormat::createCurrencyFormat(const Locale& locale, UErrorCode& ec) { CurrencyFormat* fmt = NULL; if (U_SUCCESS(ec)) { fmt = new CurrencyFormat(locale, ec); if (U_FAILURE(ec)) { delete fmt; fmt = NULL; } } return fmt; } 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 */