// © 2016 and later: Unicode, Inc. and others. // License & terms of use: http://www.unicode.org/copyright.html /* ******************************************************************************* * Copyright (C) 1997-2015, International Business Machines Corporation and * others. All Rights Reserved. ******************************************************************************* * * File NUMFMT.CPP * * Modification History: * * Date Name Description * 02/19/97 aliu Converted from java. * 03/18/97 clhuang Implemented with C++ APIs. * 04/17/97 aliu Enlarged MAX_INTEGER_DIGITS to fully accomodate the * largest double, by default. * Changed DigitCount to int per code review. * 07/20/98 stephen Changed operator== to check for grouping * Changed setMaxIntegerDigits per Java implementation. * Changed setMinIntegerDigits per Java implementation. * Changed setMinFractionDigits per Java implementation. * Changed setMaxFractionDigits per Java implementation. ******************************************************************************** */ #include "unicode/utypes.h" #if !UCONFIG_NO_FORMATTING #include "unicode/numfmt.h" #include "unicode/locid.h" #include "unicode/dcfmtsym.h" #include "unicode/decimfmt.h" #include "unicode/ustring.h" #include "unicode/ucurr.h" #include "unicode/curramt.h" #include "unicode/numsys.h" #include "unicode/rbnf.h" #include "unicode/localpointer.h" #include "unicode/udisplaycontext.h" #include "charstr.h" #include "winnmfmt.h" #include "uresimp.h" #include "uhash.h" #include "cmemory.h" #include "servloc.h" #include "ucln_in.h" #include "cstring.h" #include "putilimp.h" #include "uassert.h" #include "umutex.h" #include "mutex.h" #include #include "sharednumberformat.h" #include "unifiedcache.h" #include "number_decimalquantity.h" #include "number_utils.h" //#define FMT_DEBUG #ifdef FMT_DEBUG #include static inline void debugout(UnicodeString s) { char buf[2000]; s.extract((int32_t) 0, s.length(), buf); printf("%s", buf); } #define debug(x) printf("%s", x); #else #define debugout(x) #define debug(x) #endif // If no number pattern can be located for a locale, this is the last // resort. The patterns are same as the ones in root locale. static const UChar gLastResortDecimalPat[] = { 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0 /* "#,##0.###" */ }; static const UChar gLastResortCurrencyPat[] = { 0xA4, 0xA0, 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x30, 0x30, 0 /* "\u00A4\u00A0#,##0.00" */ }; static const UChar gLastResortPercentPat[] = { 0x23, 0x2C, 0x23, 0x23, 0x30, 0x25, 0 /* "#,##0%" */ }; static const UChar gLastResortScientificPat[] = { 0x23, 0x45, 0x30, 0 /* "#E0" */ }; static const UChar gLastResortIsoCurrencyPat[] = { 0xA4, 0xA4, 0xA0, 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x30, 0x30, 0 /* "\u00A4\u00A4\u00A0#,##0.00" */ }; static const UChar gLastResortPluralCurrencyPat[] = { 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0x20, 0xA4, 0xA4, 0xA4, 0 /* "#,##0.### \u00A4\u00A4\u00A4*/ }; static const UChar gLastResortAccountingCurrencyPat[] = { 0xA4, 0xA0, 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x30, 0x30, 0 /* "\u00A4\u00A0#,##0.00" */ }; static const UChar gSingleCurrencySign[] = {0xA4, 0}; static const UChar gDoubleCurrencySign[] = {0xA4, 0xA4, 0}; static const UChar gSlash = 0x2f; // If the maximum base 10 exponent were 4, then the largest number would // be 99,999 which has 5 digits. // On IEEE754 systems gMaxIntegerDigits is 308 + possible denormalized 15 digits + rounding digit // With big decimal, the max exponent is 999,999,999 and the max number of digits is the same, 999,999,999 const int32_t icu::NumberFormat::gDefaultMaxIntegerDigits = 2000000000; const int32_t icu::NumberFormat::gDefaultMinIntegerDigits = 127; static const UChar * const gLastResortNumberPatterns[UNUM_FORMAT_STYLE_COUNT] = { NULL, // UNUM_PATTERN_DECIMAL gLastResortDecimalPat, // UNUM_DECIMAL gLastResortCurrencyPat, // UNUM_CURRENCY gLastResortPercentPat, // UNUM_PERCENT gLastResortScientificPat, // UNUM_SCIENTIFIC NULL, // UNUM_SPELLOUT NULL, // UNUM_ORDINAL NULL, // UNUM_DURATION NULL, // UNUM_NUMBERING_SYSTEM NULL, // UNUM_PATTERN_RULEBASED gLastResortIsoCurrencyPat, // UNUM_CURRENCY_ISO gLastResortPluralCurrencyPat, // UNUM_CURRENCY_PLURAL gLastResortAccountingCurrencyPat, // UNUM_CURRENCY_ACCOUNTING gLastResortCurrencyPat, // UNUM_CASH_CURRENCY NULL, // UNUM_DECIMAL_COMPACT_SHORT NULL, // UNUM_DECIMAL_COMPACT_LONG gLastResortCurrencyPat, // UNUM_CURRENCY_STANDARD }; // Keys used for accessing resource bundles static const icu::number::impl::CldrPatternStyle gFormatCldrStyles[UNUM_FORMAT_STYLE_COUNT] = { /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_PATTERN_DECIMAL icu::number::impl::CLDR_PATTERN_STYLE_DECIMAL, // UNUM_DECIMAL icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY, // UNUM_CURRENCY icu::number::impl::CLDR_PATTERN_STYLE_PERCENT, // UNUM_PERCENT icu::number::impl::CLDR_PATTERN_STYLE_SCIENTIFIC, // UNUM_SCIENTIFIC /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_SPELLOUT /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_ORDINAL /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_DURATION /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_NUMBERING_SYSTEM /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_PATTERN_RULEBASED // For UNUM_CURRENCY_ISO and UNUM_CURRENCY_PLURAL, // the pattern is the same as the pattern of UNUM_CURRENCY // except for replacing the single currency sign with // double currency sign or triple currency sign. icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY, // UNUM_CURRENCY_ISO icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY, // UNUM_CURRENCY_PLURAL icu::number::impl::CLDR_PATTERN_STYLE_ACCOUNTING, // UNUM_CURRENCY_ACCOUNTING icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY, // UNUM_CASH_CURRENCY /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_DECIMAL_COMPACT_SHORT /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_DECIMAL_COMPACT_LONG icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY, // UNUM_CURRENCY_STANDARD }; // Static hashtable cache of NumberingSystem objects used by NumberFormat static UHashtable * NumberingSystem_cache = NULL; static icu::UInitOnce gNSCacheInitOnce = U_INITONCE_INITIALIZER; #if !UCONFIG_NO_SERVICE static icu::ICULocaleService* gService = NULL; static icu::UInitOnce gServiceInitOnce = U_INITONCE_INITIALIZER; #endif /** * Release all static memory held by Number Format. */ U_CDECL_BEGIN static void U_CALLCONV deleteNumberingSystem(void *obj) { delete (icu::NumberingSystem *)obj; } static UBool U_CALLCONV numfmt_cleanup(void) { #if !UCONFIG_NO_SERVICE gServiceInitOnce.reset(); if (gService) { delete gService; gService = NULL; } #endif gNSCacheInitOnce.reset(); if (NumberingSystem_cache) { // delete NumberingSystem_cache; uhash_close(NumberingSystem_cache); NumberingSystem_cache = NULL; } return TRUE; } U_CDECL_END // ***************************************************************************** // class NumberFormat // ***************************************************************************** U_NAMESPACE_BEGIN UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(NumberFormat) #if !UCONFIG_NO_SERVICE // ------------------------------------- // SimpleNumberFormatFactory implementation NumberFormatFactory::~NumberFormatFactory() {} SimpleNumberFormatFactory::SimpleNumberFormatFactory(const Locale& locale, UBool visible) : _visible(visible) { LocaleUtility::initNameFromLocale(locale, _id); } SimpleNumberFormatFactory::~SimpleNumberFormatFactory() {} UBool SimpleNumberFormatFactory::visible(void) const { return _visible; } const UnicodeString * SimpleNumberFormatFactory::getSupportedIDs(int32_t &count, UErrorCode& status) const { if (U_SUCCESS(status)) { count = 1; return &_id; } count = 0; return NULL; } #endif /* #if !UCONFIG_NO_SERVICE */ // ------------------------------------- // default constructor NumberFormat::NumberFormat() : fGroupingUsed(TRUE), fMaxIntegerDigits(gDefaultMaxIntegerDigits), fMinIntegerDigits(1), fMaxFractionDigits(3), // invariant, >= minFractionDigits fMinFractionDigits(0), fParseIntegerOnly(FALSE), fLenient(FALSE), fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE) { fCurrency[0] = 0; } // ------------------------------------- NumberFormat::~NumberFormat() { } SharedNumberFormat::~SharedNumberFormat() { delete ptr; } // ------------------------------------- // copy constructor NumberFormat::NumberFormat(const NumberFormat &source) : Format(source) { *this = source; } // ------------------------------------- // assignment operator NumberFormat& NumberFormat::operator=(const NumberFormat& rhs) { if (this != &rhs) { Format::operator=(rhs); fGroupingUsed = rhs.fGroupingUsed; fMaxIntegerDigits = rhs.fMaxIntegerDigits; fMinIntegerDigits = rhs.fMinIntegerDigits; fMaxFractionDigits = rhs.fMaxFractionDigits; fMinFractionDigits = rhs.fMinFractionDigits; fParseIntegerOnly = rhs.fParseIntegerOnly; u_strncpy(fCurrency, rhs.fCurrency, 3); fCurrency[3] = 0; fLenient = rhs.fLenient; fCapitalizationContext = rhs.fCapitalizationContext; } return *this; } // ------------------------------------- UBool NumberFormat::operator==(const Format& that) const { // Format::operator== guarantees this cast is safe NumberFormat* other = (NumberFormat*)&that; #ifdef FMT_DEBUG // This code makes it easy to determine why two format objects that should // be equal aren't. UBool first = TRUE; if (!Format::operator==(that)) { if (first) { printf("[ "); first = FALSE; } else { printf(", "); } debug("Format::!="); } if (!(fMaxIntegerDigits == other->fMaxIntegerDigits && fMinIntegerDigits == other->fMinIntegerDigits)) { if (first) { printf("[ "); first = FALSE; } else { printf(", "); } debug("Integer digits !="); } if (!(fMaxFractionDigits == other->fMaxFractionDigits && fMinFractionDigits == other->fMinFractionDigits)) { if (first) { printf("[ "); first = FALSE; } else { printf(", "); } debug("Fraction digits !="); } if (!(fGroupingUsed == other->fGroupingUsed)) { if (first) { printf("[ "); first = FALSE; } else { printf(", "); } debug("fGroupingUsed != "); } if (!(fParseIntegerOnly == other->fParseIntegerOnly)) { if (first) { printf("[ "); first = FALSE; } else { printf(", "); } debug("fParseIntegerOnly != "); } if (!(u_strcmp(fCurrency, other->fCurrency) == 0)) { if (first) { printf("[ "); first = FALSE; } else { printf(", "); } debug("fCurrency !="); } if (!(fLenient == other->fLenient)) { if (first) { printf("[ "); first = FALSE; } else { printf(", "); } debug("fLenient != "); } if (!(fCapitalizationContext == other->fCapitalizationContext)) { if (first) { printf("[ "); first = FALSE; } else { printf(", "); } debug("fCapitalizationContext != "); } if (!first) { printf(" ]"); } #endif return ((this == &that) || ((Format::operator==(that) && fMaxIntegerDigits == other->fMaxIntegerDigits && fMinIntegerDigits == other->fMinIntegerDigits && fMaxFractionDigits == other->fMaxFractionDigits && fMinFractionDigits == other->fMinFractionDigits && fGroupingUsed == other->fGroupingUsed && fParseIntegerOnly == other->fParseIntegerOnly && u_strcmp(fCurrency, other->fCurrency) == 0 && fLenient == other->fLenient && fCapitalizationContext == other->fCapitalizationContext))); } // ------------------------------------- // Default implementation sets unsupported error; subclasses should // override. UnicodeString& NumberFormat::format(double /* unused number */, UnicodeString& toAppendTo, FieldPositionIterator* /* unused posIter */, UErrorCode& status) const { if (!U_FAILURE(status)) { status = U_UNSUPPORTED_ERROR; } return toAppendTo; } // ------------------------------------- // Default implementation sets unsupported error; subclasses should // override. UnicodeString& NumberFormat::format(int32_t /* unused number */, UnicodeString& toAppendTo, FieldPositionIterator* /* unused posIter */, UErrorCode& status) const { if (!U_FAILURE(status)) { status = U_UNSUPPORTED_ERROR; } return toAppendTo; } // ------------------------------------- // Default implementation sets unsupported error; subclasses should // override. UnicodeString& NumberFormat::format(int64_t /* unused number */, UnicodeString& toAppendTo, FieldPositionIterator* /* unused posIter */, UErrorCode& status) const { if (!U_FAILURE(status)) { status = U_UNSUPPORTED_ERROR; } return toAppendTo; } // ------------------------------------------ // These functions add the status code, just fall back to the non-status versions UnicodeString& NumberFormat::format(double number, UnicodeString& appendTo, FieldPosition& pos, UErrorCode &status) const { if(U_SUCCESS(status)) { return format(number,appendTo,pos); } else { return appendTo; } } UnicodeString& NumberFormat::format(int32_t number, UnicodeString& appendTo, FieldPosition& pos, UErrorCode &status) const { if(U_SUCCESS(status)) { return format(number,appendTo,pos); } else { return appendTo; } } UnicodeString& NumberFormat::format(int64_t number, UnicodeString& appendTo, FieldPosition& pos, UErrorCode &status) const { if(U_SUCCESS(status)) { return format(number,appendTo,pos); } else { return appendTo; } } // ------------------------------------- // Decimal Number format() default implementation // Subclasses do not normally override this function, but rather the DigitList // formatting functions.. // The expected call chain from here is // this function -> // NumberFormat::format(Formattable -> // DecimalFormat::format(DigitList // // Or, for subclasses of Formattable that do not know about DigitList, // this Function -> // NumberFormat::format(Formattable -> // NumberFormat::format(DigitList -> // XXXFormat::format(double UnicodeString& NumberFormat::format(StringPiece decimalNum, UnicodeString& toAppendTo, FieldPositionIterator* fpi, UErrorCode& status) const { Formattable f; f.setDecimalNumber(decimalNum, status); format(f, toAppendTo, fpi, status); return toAppendTo; } /** * // Formats the number object and save the format // result in the toAppendTo string buffer. // utility to save/restore state, used in two overloads // of format(const Formattable&...) below. * * Old purpose of ArgExtractor was to avoid const. Not thread safe! * * keeping it around as a shim. */ class ArgExtractor { const Formattable* num; UChar save[4]; UBool fWasCurrency; public: ArgExtractor(const NumberFormat& nf, const Formattable& obj, UErrorCode& status); ~ArgExtractor(); const Formattable* number(void) const; const UChar *iso(void) const; UBool wasCurrency(void) const; }; inline const Formattable* ArgExtractor::number(void) const { return num; } inline UBool ArgExtractor::wasCurrency(void) const { return fWasCurrency; } inline const UChar * ArgExtractor::iso(void) const { return save; } ArgExtractor::ArgExtractor(const NumberFormat& /*nf*/, const Formattable& obj, UErrorCode& /*status*/) : num(&obj), fWasCurrency(FALSE) { const UObject* o = obj.getObject(); // most commonly o==NULL const CurrencyAmount* amt; if (o != NULL && (amt = dynamic_cast(o)) != NULL) { // getISOCurrency() returns a pointer to internal storage, so we // copy it to retain it across the call to setCurrency(). //const UChar* curr = amt->getISOCurrency(); u_strcpy(save, amt->getISOCurrency()); num = &amt->getNumber(); fWasCurrency=TRUE; } else { save[0]=0; } } ArgExtractor::~ArgExtractor() { } UnicodeString& NumberFormat::format(const number::impl::DecimalQuantity &number, UnicodeString& appendTo, FieldPositionIterator* posIter, UErrorCode& status) const { // DecimalFormat overrides this function, and handles DigitList based big decimals. // Other subclasses (ChoiceFormat) do not (yet) handle DigitLists, // so this default implementation falls back to formatting decimal numbers as doubles. if (U_FAILURE(status)) { return appendTo; } double dnum = number.toDouble(); format(dnum, appendTo, posIter, status); return appendTo; } UnicodeString& NumberFormat::format(const number::impl::DecimalQuantity &number, UnicodeString& appendTo, FieldPosition& pos, UErrorCode &status) const { // DecimalFormat overrides this function, and handles DigitList based big decimals. // Other subclasses (ChoiceFormat) do not (yet) handle DigitLists, // so this default implementation falls back to formatting decimal numbers as doubles. if (U_FAILURE(status)) { return appendTo; } double dnum = number.toDouble(); format(dnum, appendTo, pos, status); return appendTo; } UnicodeString& NumberFormat::format(const Formattable& obj, UnicodeString& appendTo, FieldPosition& pos, UErrorCode& status) const { if (U_FAILURE(status)) return appendTo; ArgExtractor arg(*this, obj, status); const Formattable *n = arg.number(); const UChar *iso = arg.iso(); if(arg.wasCurrency() && u_strcmp(iso, getCurrency())) { // trying to format a different currency. // Right now, we clone. LocalPointer cloneFmt((NumberFormat*)this->clone()); cloneFmt->setCurrency(iso, status); // next line should NOT recurse, because n is numeric whereas obj was a wrapper around currency amount. return cloneFmt->format(*n, appendTo, pos, status); } if (n->isNumeric() && n->getDecimalQuantity() != NULL) { // Decimal Number. We will have a DigitList available if the value was // set to a decimal number, or if the value originated with a parse. // // The default implementation for formatting a DigitList converts it // to a double, and formats that, allowing formatting classes that don't // know about DigitList to continue to operate as they had. // // DecimalFormat overrides the DigitList formatting functions. format(*n->getDecimalQuantity(), appendTo, pos, status); } else { switch (n->getType()) { case Formattable::kDouble: format(n->getDouble(), appendTo, pos, status); break; case Formattable::kLong: format(n->getLong(), appendTo, pos, status); break; case Formattable::kInt64: format(n->getInt64(), appendTo, pos, status); break; default: status = U_INVALID_FORMAT_ERROR; break; } } return appendTo; } // -------------------------------------x // Formats the number object and save the format // result in the toAppendTo string buffer. UnicodeString& NumberFormat::format(const Formattable& obj, UnicodeString& appendTo, FieldPositionIterator* posIter, UErrorCode& status) const { if (U_FAILURE(status)) return appendTo; ArgExtractor arg(*this, obj, status); const Formattable *n = arg.number(); const UChar *iso = arg.iso(); if(arg.wasCurrency() && u_strcmp(iso, getCurrency())) { // trying to format a different currency. // Right now, we clone. LocalPointer cloneFmt((NumberFormat*)this->clone()); cloneFmt->setCurrency(iso, status); // next line should NOT recurse, because n is numeric whereas obj was a wrapper around currency amount. return cloneFmt->format(*n, appendTo, posIter, status); } if (n->isNumeric() && n->getDecimalQuantity() != NULL) { // Decimal Number format(*n->getDecimalQuantity(), appendTo, posIter, status); } else { switch (n->getType()) { case Formattable::kDouble: format(n->getDouble(), appendTo, posIter, status); break; case Formattable::kLong: format(n->getLong(), appendTo, posIter, status); break; case Formattable::kInt64: format(n->getInt64(), appendTo, posIter, status); break; default: status = U_INVALID_FORMAT_ERROR; break; } } return appendTo; } // ------------------------------------- UnicodeString& NumberFormat::format(int64_t number, UnicodeString& appendTo, FieldPosition& pos) const { // default so we don't introduce a new abstract method return format((int32_t)number, appendTo, pos); } // ------------------------------------- // Parses the string and save the result object as well // as the final parsed position. void NumberFormat::parseObject(const UnicodeString& source, Formattable& result, ParsePosition& parse_pos) const { parse(source, result, parse_pos); } // ------------------------------------- // Formats a double number and save the result in a string. UnicodeString& NumberFormat::format(double number, UnicodeString& appendTo) const { FieldPosition pos(FieldPosition::DONT_CARE); return format(number, appendTo, pos); } // ------------------------------------- // Formats a long number and save the result in a string. UnicodeString& NumberFormat::format(int32_t number, UnicodeString& appendTo) const { FieldPosition pos(FieldPosition::DONT_CARE); return format(number, appendTo, pos); } // ------------------------------------- // Formats a long number and save the result in a string. UnicodeString& NumberFormat::format(int64_t number, UnicodeString& appendTo) const { FieldPosition pos(FieldPosition::DONT_CARE); return format(number, appendTo, pos); } // ------------------------------------- // Parses the text and save the result object. If the returned // parse position is 0, that means the parsing failed, the status // code needs to be set to failure. Ignores the returned parse // position, otherwise. void NumberFormat::parse(const UnicodeString& text, Formattable& result, UErrorCode& status) const { if (U_FAILURE(status)) return; ParsePosition parsePosition(0); parse(text, result, parsePosition); if (parsePosition.getIndex() == 0) { status = U_INVALID_FORMAT_ERROR; } } CurrencyAmount* NumberFormat::parseCurrency(const UnicodeString& text, ParsePosition& pos) const { // Default implementation only -- subclasses should override Formattable parseResult; int32_t start = pos.getIndex(); parse(text, parseResult, pos); if (pos.getIndex() != start) { UChar curr[4]; UErrorCode ec = U_ZERO_ERROR; getEffectiveCurrency(curr, ec); if (U_SUCCESS(ec)) { LocalPointer currAmt(new CurrencyAmount(parseResult, curr, ec), ec); if (U_FAILURE(ec)) { pos.setIndex(start); // indicate failure } else { return currAmt.orphan(); } } } return NULL; } // ------------------------------------- // Sets to only parse integers. void NumberFormat::setParseIntegerOnly(UBool value) { fParseIntegerOnly = value; } // ------------------------------------- // Sets whether lenient parse is enabled. void NumberFormat::setLenient(UBool enable) { fLenient = enable; } // ------------------------------------- // Create a number style NumberFormat instance with the default locale. NumberFormat* U_EXPORT2 NumberFormat::createInstance(UErrorCode& status) { return createInstance(Locale::getDefault(), UNUM_DECIMAL, status); } // ------------------------------------- // Create a number style NumberFormat instance with the inLocale locale. NumberFormat* U_EXPORT2 NumberFormat::createInstance(const Locale& inLocale, UErrorCode& status) { return createInstance(inLocale, UNUM_DECIMAL, status); } // ------------------------------------- // Create a currency style NumberFormat instance with the default locale. NumberFormat* U_EXPORT2 NumberFormat::createCurrencyInstance(UErrorCode& status) { return createCurrencyInstance(Locale::getDefault(), status); } // ------------------------------------- // Create a currency style NumberFormat instance with the inLocale locale. NumberFormat* U_EXPORT2 NumberFormat::createCurrencyInstance(const Locale& inLocale, UErrorCode& status) { return createInstance(inLocale, UNUM_CURRENCY, status); } // ------------------------------------- // Create a percent style NumberFormat instance with the default locale. NumberFormat* U_EXPORT2 NumberFormat::createPercentInstance(UErrorCode& status) { return createInstance(Locale::getDefault(), UNUM_PERCENT, status); } // ------------------------------------- // Create a percent style NumberFormat instance with the inLocale locale. NumberFormat* U_EXPORT2 NumberFormat::createPercentInstance(const Locale& inLocale, UErrorCode& status) { return createInstance(inLocale, UNUM_PERCENT, status); } // ------------------------------------- // Create a scientific style NumberFormat instance with the default locale. NumberFormat* U_EXPORT2 NumberFormat::createScientificInstance(UErrorCode& status) { return createInstance(Locale::getDefault(), UNUM_SCIENTIFIC, status); } // ------------------------------------- // Create a scientific style NumberFormat instance with the inLocale locale. NumberFormat* U_EXPORT2 NumberFormat::createScientificInstance(const Locale& inLocale, UErrorCode& status) { return createInstance(inLocale, UNUM_SCIENTIFIC, status); } // ------------------------------------- const Locale* U_EXPORT2 NumberFormat::getAvailableLocales(int32_t& count) { return Locale::getAvailableLocales(count); } // ------------------------------------------ // // Registration // //------------------------------------------- #if !UCONFIG_NO_SERVICE // ------------------------------------- class ICUNumberFormatFactory : public ICUResourceBundleFactory { public: virtual ~ICUNumberFormatFactory(); protected: virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /* service */, UErrorCode& status) const { return NumberFormat::makeInstance(loc, (UNumberFormatStyle)kind, status); } }; ICUNumberFormatFactory::~ICUNumberFormatFactory() {} // ------------------------------------- class NFFactory : public LocaleKeyFactory { private: NumberFormatFactory* _delegate; Hashtable* _ids; public: NFFactory(NumberFormatFactory* delegate) : LocaleKeyFactory(delegate->visible() ? VISIBLE : INVISIBLE) , _delegate(delegate) , _ids(NULL) { } virtual ~NFFactory(); virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const { if (handlesKey(key, status)) { const LocaleKey& lkey = (const LocaleKey&)key; Locale loc; lkey.canonicalLocale(loc); int32_t kind = lkey.kind(); UObject* result = _delegate->createFormat(loc, (UNumberFormatStyle)kind); if (result == NULL) { result = service->getKey((ICUServiceKey&)key /* cast away const */, NULL, this, status); } return result; } return NULL; } protected: /** * Return the set of ids that this factory supports (visible or * otherwise). This can be called often and might need to be * cached if it is expensive to create. */ virtual const Hashtable* getSupportedIDs(UErrorCode& status) const { if (U_SUCCESS(status)) { if (!_ids) { int32_t count = 0; const UnicodeString * const idlist = _delegate->getSupportedIDs(count, status); ((NFFactory*)this)->_ids = new Hashtable(status); /* cast away const */ if (_ids) { for (int i = 0; i < count; ++i) { _ids->put(idlist[i], (void*)this, status); } } } return _ids; } return NULL; } }; NFFactory::~NFFactory() { delete _delegate; delete _ids; } class ICUNumberFormatService : public ICULocaleService { public: ICUNumberFormatService() : ICULocaleService(UNICODE_STRING_SIMPLE("Number Format")) { UErrorCode status = U_ZERO_ERROR; registerFactory(new ICUNumberFormatFactory(), status); } virtual ~ICUNumberFormatService(); virtual UObject* cloneInstance(UObject* instance) const { return ((NumberFormat*)instance)->clone(); } virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /* actualID */, UErrorCode& status) const { LocaleKey& lkey = (LocaleKey&)key; int32_t kind = lkey.kind(); Locale loc; lkey.currentLocale(loc); return NumberFormat::makeInstance(loc, (UNumberFormatStyle)kind, status); } virtual UBool isDefault() const { return countFactories() == 1; } }; ICUNumberFormatService::~ICUNumberFormatService() {} // ------------------------------------- static void U_CALLCONV initNumberFormatService() { U_ASSERT(gService == NULL); ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup); gService = new ICUNumberFormatService(); } static ICULocaleService* getNumberFormatService(void) { umtx_initOnce(gServiceInitOnce, &initNumberFormatService); return gService; } static UBool haveService() { return !gServiceInitOnce.isReset() && (getNumberFormatService() != NULL); } // ------------------------------------- URegistryKey U_EXPORT2 NumberFormat::registerFactory(NumberFormatFactory* toAdopt, UErrorCode& status) { ICULocaleService *service = getNumberFormatService(); if (service) { NFFactory *tempnnf = new NFFactory(toAdopt); if (tempnnf != NULL) { return service->registerFactory(tempnnf, status); } } status = U_MEMORY_ALLOCATION_ERROR; return NULL; } // ------------------------------------- UBool U_EXPORT2 NumberFormat::unregister(URegistryKey key, UErrorCode& status) { if (U_FAILURE(status)) { return FALSE; } if (haveService()) { return gService->unregister(key, status); } else { status = U_ILLEGAL_ARGUMENT_ERROR; return FALSE; } } // ------------------------------------- StringEnumeration* U_EXPORT2 NumberFormat::getAvailableLocales(void) { ICULocaleService *service = getNumberFormatService(); if (service) { return service->getAvailableLocales(); } return NULL; // no way to return error condition } #endif /* UCONFIG_NO_SERVICE */ // ------------------------------------- enum { kKeyValueLenMax = 32 }; NumberFormat* NumberFormat::internalCreateInstance(const Locale& loc, UNumberFormatStyle kind, UErrorCode& status) { if (kind == UNUM_CURRENCY) { char cfKeyValue[kKeyValueLenMax] = {0}; UErrorCode kvStatus = U_ZERO_ERROR; int32_t kLen = loc.getKeywordValue("cf", cfKeyValue, kKeyValueLenMax, kvStatus); if (U_SUCCESS(kvStatus) && kLen > 0 && uprv_strcmp(cfKeyValue,"account")==0) { kind = UNUM_CURRENCY_ACCOUNTING; } } #if !UCONFIG_NO_SERVICE if (haveService()) { return (NumberFormat*)gService->get(loc, kind, status); } #endif return makeInstance(loc, kind, status); } NumberFormat* U_EXPORT2 NumberFormat::createInstance(const Locale& loc, UNumberFormatStyle kind, UErrorCode& status) { if (kind != UNUM_DECIMAL) { return internalCreateInstance(loc, kind, status); } const SharedNumberFormat *shared = createSharedInstance(loc, kind, status); if (U_FAILURE(status)) { return NULL; } NumberFormat *result = static_cast((*shared)->clone()); shared->removeRef(); if (result == NULL) { status = U_MEMORY_ALLOCATION_ERROR; } return result; } // ------------------------------------- // Checks if the thousand/10 thousand grouping is used in the // NumberFormat instance. UBool NumberFormat::isGroupingUsed() const { return fGroupingUsed; } // ------------------------------------- // Sets to use the thousand/10 thousand grouping in the // NumberFormat instance. void NumberFormat::setGroupingUsed(UBool newValue) { fGroupingUsed = newValue; } // ------------------------------------- // Gets the maximum number of digits for the integral part for // this NumberFormat instance. int32_t NumberFormat::getMaximumIntegerDigits() const { return fMaxIntegerDigits; } // ------------------------------------- // Sets the maximum number of digits for the integral part for // this NumberFormat instance. void NumberFormat::setMaximumIntegerDigits(int32_t newValue) { fMaxIntegerDigits = uprv_max(0, uprv_min(newValue, gDefaultMaxIntegerDigits)); if(fMinIntegerDigits > fMaxIntegerDigits) fMinIntegerDigits = fMaxIntegerDigits; } // ------------------------------------- // Gets the minimum number of digits for the integral part for // this NumberFormat instance. int32_t NumberFormat::getMinimumIntegerDigits() const { return fMinIntegerDigits; } // ------------------------------------- // Sets the minimum number of digits for the integral part for // this NumberFormat instance. void NumberFormat::setMinimumIntegerDigits(int32_t newValue) { fMinIntegerDigits = uprv_max(0, uprv_min(newValue, gDefaultMinIntegerDigits)); if(fMinIntegerDigits > fMaxIntegerDigits) fMaxIntegerDigits = fMinIntegerDigits; } // ------------------------------------- // Gets the maximum number of digits for the fractional part for // this NumberFormat instance. int32_t NumberFormat::getMaximumFractionDigits() const { return fMaxFractionDigits; } // ------------------------------------- // Sets the maximum number of digits for the fractional part for // this NumberFormat instance. void NumberFormat::setMaximumFractionDigits(int32_t newValue) { fMaxFractionDigits = uprv_max(0, uprv_min(newValue, gDefaultMaxIntegerDigits)); if(fMaxFractionDigits < fMinFractionDigits) fMinFractionDigits = fMaxFractionDigits; } // ------------------------------------- // Gets the minimum number of digits for the fractional part for // this NumberFormat instance. int32_t NumberFormat::getMinimumFractionDigits() const { return fMinFractionDigits; } // ------------------------------------- // Sets the minimum number of digits for the fractional part for // this NumberFormat instance. void NumberFormat::setMinimumFractionDigits(int32_t newValue) { fMinFractionDigits = uprv_max(0, uprv_min(newValue, gDefaultMinIntegerDigits)); if (fMaxFractionDigits < fMinFractionDigits) fMaxFractionDigits = fMinFractionDigits; } // ------------------------------------- void NumberFormat::setCurrency(const UChar* theCurrency, UErrorCode& ec) { if (U_FAILURE(ec)) { return; } if (theCurrency) { u_strncpy(fCurrency, theCurrency, 3); fCurrency[3] = 0; } else { fCurrency[0] = 0; } } const char16_t* NumberFormat::getCurrency() const { return fCurrency; } void NumberFormat::getEffectiveCurrency(UChar* result, UErrorCode& ec) const { const UChar* c = getCurrency(); if (*c != 0) { u_strncpy(result, c, 3); result[3] = 0; } else { const char* loc = getLocaleID(ULOC_VALID_LOCALE, ec); if (loc == NULL) { loc = uloc_getDefault(); } ucurr_forLocale(loc, result, 4, &ec); } } //---------------------------------------------------------------------- void NumberFormat::setContext(UDisplayContext value, UErrorCode& status) { if (U_FAILURE(status)) return; if ( (UDisplayContextType)((uint32_t)value >> 8) == UDISPCTX_TYPE_CAPITALIZATION ) { fCapitalizationContext = value; } else { status = U_ILLEGAL_ARGUMENT_ERROR; } } UDisplayContext NumberFormat::getContext(UDisplayContextType type, UErrorCode& status) const { if (U_FAILURE(status)) return (UDisplayContext)0; if (type != UDISPCTX_TYPE_CAPITALIZATION) { status = U_ILLEGAL_ARGUMENT_ERROR; return (UDisplayContext)0; } return fCapitalizationContext; } // ------------------------------------- // Creates the NumberFormat instance of the specified style (number, currency, // or percent) for the desired locale. static void U_CALLCONV nscacheInit() { U_ASSERT(NumberingSystem_cache == NULL); ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup); UErrorCode status = U_ZERO_ERROR; NumberingSystem_cache = uhash_open(uhash_hashLong, uhash_compareLong, NULL, &status); if (U_FAILURE(status)) { // Number Format code will run with no cache if creation fails. NumberingSystem_cache = NULL; return; } uhash_setValueDeleter(NumberingSystem_cache, deleteNumberingSystem); } template<> U_I18N_API const SharedNumberFormat *LocaleCacheKey::createObject( const void * /*unused*/, UErrorCode &status) const { const char *localeId = fLoc.getName(); NumberFormat *nf = NumberFormat::internalCreateInstance( localeId, UNUM_DECIMAL, status); if (U_FAILURE(status)) { return NULL; } SharedNumberFormat *result = new SharedNumberFormat(nf); if (result == NULL) { status = U_MEMORY_ALLOCATION_ERROR; delete nf; return NULL; } result->addRef(); return result; } const SharedNumberFormat* U_EXPORT2 NumberFormat::createSharedInstance(const Locale& loc, UNumberFormatStyle kind, UErrorCode& status) { if (U_FAILURE(status)) { return NULL; } if (kind != UNUM_DECIMAL) { status = U_UNSUPPORTED_ERROR; return NULL; } const SharedNumberFormat *result = NULL; UnifiedCache::getByLocale(loc, result, status); return result; } UBool NumberFormat::isStyleSupported(UNumberFormatStyle style) { return gLastResortNumberPatterns[style] != NULL; } NumberFormat* NumberFormat::makeInstance(const Locale& desiredLocale, UNumberFormatStyle style, UErrorCode& status) { return makeInstance(desiredLocale, style, false, status); } NumberFormat* NumberFormat::makeInstance(const Locale& desiredLocale, UNumberFormatStyle style, UBool mustBeDecimalFormat, UErrorCode& status) { if (U_FAILURE(status)) return NULL; if (style < 0 || style >= UNUM_FORMAT_STYLE_COUNT) { status = U_ILLEGAL_ARGUMENT_ERROR; return NULL; } // Some styles are not supported. This is a result of merging // the @draft ICU 4.2 NumberFormat::EStyles into the long-existing UNumberFormatStyle. // Ticket #8503 is for reviewing/fixing/merging the two relevant implementations: // this one and unum_open(). // The UNUM_PATTERN_ styles are not supported here // because this method does not take a pattern string. if (!isStyleSupported(style)) { status = U_UNSUPPORTED_ERROR; return NULL; } #if U_PLATFORM_USES_ONLY_WIN32_API if (!mustBeDecimalFormat) { char buffer[8]; int32_t count = desiredLocale.getKeywordValue("compat", buffer, sizeof(buffer), status); // if the locale has "@compat=host", create a host-specific NumberFormat if (U_SUCCESS(status) && count > 0 && uprv_strcmp(buffer, "host") == 0) { UBool curr = TRUE; switch (style) { case UNUM_DECIMAL: curr = FALSE; // fall-through U_FALLTHROUGH; case UNUM_CURRENCY: case UNUM_CURRENCY_ISO: // do not support plural formatting here case UNUM_CURRENCY_PLURAL: case UNUM_CURRENCY_ACCOUNTING: case UNUM_CASH_CURRENCY: case UNUM_CURRENCY_STANDARD: { LocalPointer f(new Win32NumberFormat(desiredLocale, curr, status), status); if (U_SUCCESS(status)) { return f.orphan(); } } break; default: break; } } } #endif // Use numbering system cache hashtable umtx_initOnce(gNSCacheInitOnce, &nscacheInit); // Get cached numbering system LocalPointer ownedNs; NumberingSystem *ns = NULL; if (NumberingSystem_cache != NULL) { // TODO: Bad hash key usage, see ticket #8504. int32_t hashKey = desiredLocale.hashCode(); static icu::UMutex nscacheMutex = U_MUTEX_INITIALIZER; Mutex lock(&nscacheMutex); ns = (NumberingSystem *)uhash_iget(NumberingSystem_cache, hashKey); if (ns == NULL) { ns = NumberingSystem::createInstance(desiredLocale,status); uhash_iput(NumberingSystem_cache, hashKey, (void*)ns, &status); } } else { ownedNs.adoptInstead(NumberingSystem::createInstance(desiredLocale,status)); ns = ownedNs.getAlias(); } // check results of getting a numbering system if (U_FAILURE(status)) { return NULL; } if (mustBeDecimalFormat && ns->isAlgorithmic()) { status = U_UNSUPPORTED_ERROR; return NULL; } LocalPointer symbolsToAdopt; UnicodeString pattern; LocalUResourceBundlePointer ownedResource(ures_open(NULL, desiredLocale.getName(), &status)); if (U_FAILURE(status)) { return NULL; } else { // Loads the decimal symbols of the desired locale. symbolsToAdopt.adoptInsteadAndCheckErrorCode(new DecimalFormatSymbols(desiredLocale, status), status); if (U_FAILURE(status)) { return NULL; } // Load the pattern from data using the common library function const char16_t* patternPtr = number::impl::utils::getPatternForStyle( desiredLocale, ns->getName(), gFormatCldrStyles[style], status); pattern = UnicodeString(TRUE, patternPtr, -1); } if (U_FAILURE(status)) { return NULL; } if(style==UNUM_CURRENCY || style == UNUM_CURRENCY_ISO || style == UNUM_CURRENCY_ACCOUNTING || style == UNUM_CASH_CURRENCY || style == UNUM_CURRENCY_STANDARD){ const UChar* currPattern = symbolsToAdopt->getCurrencyPattern(); if(currPattern!=NULL){ pattern.setTo(currPattern, u_strlen(currPattern)); } } LocalPointer f; if (ns->isAlgorithmic()) { UnicodeString nsDesc; UnicodeString nsRuleSetGroup; UnicodeString nsRuleSetName; Locale nsLoc; URBNFRuleSetTag desiredRulesType = URBNF_NUMBERING_SYSTEM; nsDesc.setTo(ns->getDescription()); int32_t firstSlash = nsDesc.indexOf(gSlash); int32_t lastSlash = nsDesc.lastIndexOf(gSlash); if ( lastSlash > firstSlash ) { CharString nsLocID; nsLocID.appendInvariantChars(nsDesc.tempSubString(0, firstSlash), status); nsRuleSetGroup.setTo(nsDesc,firstSlash+1,lastSlash-firstSlash-1); nsRuleSetName.setTo(nsDesc,lastSlash+1); nsLoc = Locale::createFromName(nsLocID.data()); UnicodeString SpelloutRules = UNICODE_STRING_SIMPLE("SpelloutRules"); if ( nsRuleSetGroup.compare(SpelloutRules) == 0 ) { desiredRulesType = URBNF_SPELLOUT; } } else { nsLoc = desiredLocale; nsRuleSetName.setTo(nsDesc); } RuleBasedNumberFormat *r = new RuleBasedNumberFormat(desiredRulesType,nsLoc,status); if (r == NULL) { status = U_MEMORY_ALLOCATION_ERROR; return NULL; } r->setDefaultRuleSet(nsRuleSetName,status); f.adoptInstead(r); } else { // replace single currency sign in the pattern with double currency sign // if the style is UNUM_CURRENCY_ISO if (style == UNUM_CURRENCY_ISO) { pattern.findAndReplace(UnicodeString(TRUE, gSingleCurrencySign, 1), UnicodeString(TRUE, gDoubleCurrencySign, 2)); } // "new DecimalFormat()" does not adopt the symbols argument if its memory allocation fails. // So we can't use adoptInsteadAndCheckErrorCode as we need to know if the 'new' failed. DecimalFormatSymbols *syms = symbolsToAdopt.getAlias(); LocalPointer df(new DecimalFormat(pattern, syms, style, status)); if (df.isValid()) { // if the DecimalFormat object was successfully new'ed, then it will own symbolsToAdopt, even if the status is a failure. symbolsToAdopt.orphan(); } else { status = U_MEMORY_ALLOCATION_ERROR; } if (U_FAILURE(status)) { return nullptr; } // if it is cash currency style, setCurrencyUsage with usage if (style == UNUM_CASH_CURRENCY){ df->setCurrencyUsage(UCURR_USAGE_CASH, &status); } if (U_FAILURE(status)) { return nullptr; } f.adoptInstead(df.orphan()); } f->setLocaleIDs(ures_getLocaleByType(ownedResource.getAlias(), ULOC_VALID_LOCALE, &status), ures_getLocaleByType(ownedResource.getAlias(), ULOC_ACTUAL_LOCALE, &status)); if (U_FAILURE(status)) { return NULL; } return f.orphan(); } /** * Get the rounding mode. * @return A rounding mode */ NumberFormat::ERoundingMode NumberFormat::getRoundingMode() const { // Default value. ICU4J throws an exception and we can't change this API. return NumberFormat::ERoundingMode::kRoundUnnecessary; } /** * Set the rounding mode. This has no effect unless the rounding * increment is greater than zero. * @param roundingMode A rounding mode */ void NumberFormat::setRoundingMode(NumberFormat::ERoundingMode /*roundingMode*/) { // No-op ICU4J throws an exception, and we can't change this API. } U_NAMESPACE_END #endif /* #if !UCONFIG_NO_FORMATTING */ //eof