+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
-* Copyright (C) 1997-2003, International Business Machines Corporation and *
-* others. All Rights Reserved. *
+* Copyright (C) 1997-2015, International Business Machines Corporation and
+* others. All Rights Reserved.
*******************************************************************************
*
* File NUMFMT.CPP
#include "unicode/numfmt.h"
#include "unicode/locid.h"
-#include "unicode/resbund.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 "iculserv.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 <float.h>
+#include "sharednumberformat.h"
+#include "unifiedcache.h"
+#include "number_decimalquantity.h"
+#include "number_utils.h"
+
+//#define FMT_DEBUG
+
+#ifdef FMT_DEBUG
+#include <stdio.h>
+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.
+// resort. The patterns are same as the ones in root locale.
static const UChar gLastResortDecimalPat[] = {
- 0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0x3B, 0x2D, 0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0 /* "#0.###;-#0.###" */
+ 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0 /* "#,##0.###" */
};
static const UChar gLastResortCurrencyPat[] = {
- 0x24, 0x23, 0x30, 0x2E, 0x30, 0x30, 0x3B, 0x28, 0x24, 0x23, 0x30, 0x2E, 0x30, 0x30, 0x29, 0 /* "$#0.00;($#0.00)" */
+ 0xA4, 0xA0, 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x30, 0x30, 0 /* "\u00A4\u00A0#,##0.00" */
};
static const UChar gLastResortPercentPat[] = {
- 0x23, 0x30, 0x25, 0 /* "#0%" */
+ 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
-const char NumberFormat::fgClassID = 0; // Value is irrelevant
+UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(NumberFormat)
-// If the maximum base 10 exponent were 4, then the largest number would
-// be 99,999 which has 5 digits.
-const int32_t NumberFormat::fgMaxIntegerDigits = DBL_MAX_10_EXP + 1; // Should be ~40 ? --srl
-const int32_t NumberFormat::fgMinIntegerDigits = 127;
+#if !UCONFIG_NO_SERVICE
+// -------------------------------------
+// SimpleNumberFormatFactory implementation
+NumberFormatFactory::~NumberFormatFactory() {}
+SimpleNumberFormatFactory::SimpleNumberFormatFactory(const Locale& locale, UBool visible)
+ : _visible(visible)
+{
+ LocaleUtility::initNameFromLocale(locale, _id);
+}
-const int32_t NumberFormat::fgNumberPatternsCount = 3;
+SimpleNumberFormatFactory::~SimpleNumberFormatFactory() {}
-const UChar * const NumberFormat::fgLastResortNumberPatterns[] =
+UBool SimpleNumberFormatFactory::visible(void) const {
+ return _visible;
+}
+
+const UnicodeString *
+SimpleNumberFormatFactory::getSupportedIDs(int32_t &count, UErrorCode& status) const
{
- gLastResortDecimalPat,
- gLastResortCurrencyPat,
- gLastResortPercentPat,
- gLastResortScientificPat
-};
+ if (U_SUCCESS(status)) {
+ count = 1;
+ return &_id;
+ }
+ count = 0;
+ return NULL;
+}
+#endif /* #if !UCONFIG_NO_SERVICE */
// -------------------------------------
// default constructor
-
NumberFormat::NumberFormat()
: fGroupingUsed(TRUE),
- fMaxIntegerDigits(fgMaxIntegerDigits),
+ fMaxIntegerDigits(gDefaultMaxIntegerDigits),
fMinIntegerDigits(1),
fMaxFractionDigits(3), // invariant, >= minFractionDigits
fMinFractionDigits(0),
- fParseIntegerOnly(FALSE)
+ fParseIntegerOnly(FALSE),
+ fLenient(FALSE),
+ fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
{
+ fCurrency[0] = 0;
}
// -------------------------------------
{
}
+SharedNumberFormat::~SharedNumberFormat() {
+ delete ptr;
+}
+
// -------------------------------------
// copy constructor
{
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) &&
- getDynamicClassID()== that.getDynamicClassID() &&
fMaxIntegerDigits == other->fMaxIntegerDigits &&
fMinIntegerDigits == other->fMinIntegerDigits &&
fMaxFractionDigits == other->fMaxFractionDigits &&
fMinFractionDigits == other->fMinFractionDigits &&
fGroupingUsed == other->fGroupingUsed &&
- fParseIntegerOnly == other->fParseIntegerOnly)));
+ 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<const CurrencyAmount*>(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,
{
if (U_FAILURE(status)) return appendTo;
- if (obj.getType() == Formattable::kDouble) {
- return format(obj.getDouble(), appendTo, pos);
+ 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<NumberFormat> 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);
}
- else if (obj.getType() == Formattable::kLong) {
- return format(obj.getLong(), appendTo, pos);
+
+ 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;
+ }
}
- // can't try to format a non-numeric object
- else {
- status = U_INVALID_FORMAT_ERROR;
- return appendTo;
+
+ 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<NumberFormat> 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);
}
// -------------------------------------
UnicodeString&
NumberFormat::format(double number, UnicodeString& appendTo) const
{
- FieldPosition pos(0);
+ FieldPosition pos(FieldPosition::DONT_CARE);
return format(number, appendTo, pos);
}
UnicodeString&
NumberFormat::format(int32_t number, UnicodeString& appendTo) const
{
- FieldPosition pos(0);
+ 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);
}
}
}
+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<CurrencyAmount> 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.
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*
+NumberFormat* U_EXPORT2
NumberFormat::createInstance(UErrorCode& status)
{
- return createInstance(Locale::getDefault(), kNumberStyle, status);
+ return createInstance(Locale::getDefault(), UNUM_DECIMAL, status);
}
// -------------------------------------
// Create a number style NumberFormat instance with the inLocale locale.
-NumberFormat*
+NumberFormat* U_EXPORT2
NumberFormat::createInstance(const Locale& inLocale, UErrorCode& status)
{
- return createInstance(inLocale, kNumberStyle, status);
+ return createInstance(inLocale, UNUM_DECIMAL, status);
}
// -------------------------------------
// Create a currency style NumberFormat instance with the default locale.
-NumberFormat*
+NumberFormat* U_EXPORT2
NumberFormat::createCurrencyInstance(UErrorCode& status)
{
- return createInstance(Locale::getDefault(), kCurrencyStyle, status);
+ return createCurrencyInstance(Locale::getDefault(), status);
}
// -------------------------------------
// Create a currency style NumberFormat instance with the inLocale locale.
-NumberFormat*
+NumberFormat* U_EXPORT2
NumberFormat::createCurrencyInstance(const Locale& inLocale, UErrorCode& status)
{
- return createInstance(inLocale, kCurrencyStyle, status);
+ return createInstance(inLocale, UNUM_CURRENCY, status);
}
// -------------------------------------
// Create a percent style NumberFormat instance with the default locale.
-NumberFormat*
+NumberFormat* U_EXPORT2
NumberFormat::createPercentInstance(UErrorCode& status)
{
- return createInstance(Locale::getDefault(), kPercentStyle, status);
+ return createInstance(Locale::getDefault(), UNUM_PERCENT, status);
}
// -------------------------------------
// Create a percent style NumberFormat instance with the inLocale locale.
-NumberFormat*
+NumberFormat* U_EXPORT2
NumberFormat::createPercentInstance(const Locale& inLocale, UErrorCode& status)
{
- return createInstance(inLocale, kPercentStyle, status);
+ return createInstance(inLocale, UNUM_PERCENT, status);
}
// -------------------------------------
// Create a scientific style NumberFormat instance with the default locale.
-NumberFormat*
+NumberFormat* U_EXPORT2
NumberFormat::createScientificInstance(UErrorCode& status)
{
- return createInstance(Locale::getDefault(), kScientificStyle, status);
+ return createInstance(Locale::getDefault(), UNUM_SCIENTIFIC, status);
}
// -------------------------------------
// Create a scientific style NumberFormat instance with the inLocale locale.
-NumberFormat*
+NumberFormat* U_EXPORT2
NumberFormat::createScientificInstance(const Locale& inLocale, UErrorCode& status)
{
- return createInstance(inLocale, kScientificStyle, status);
+ return createInstance(inLocale, UNUM_SCIENTIFIC, status);
}
// -------------------------------------
-const Locale*
+const Locale* U_EXPORT2
NumberFormat::getAvailableLocales(int32_t& count)
{
return Locale::getAvailableLocales(count);
//
//-------------------------------------------
-static ICULocaleService* gService = NULL;
+#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 {
-// !!! kind is not an EStyles, need to determine how to handle this
- return NumberFormat::makeInstance(loc, (NumberFormat::EStyles)kind, status);
- }
+ 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;
+ NumberFormatFactory* _delegate;
+ Hashtable* _ids;
public:
- NFFactory(NumberFormatFactory* delegate)
- : LocaleKeyFactory(delegate->visible() ? VISIBLE : INVISIBLE)
- , _delegate(delegate)
- , _ids(NULL)
- {
- }
-
- virtual ~NFFactory()
- {
- delete _delegate;
- delete _ids;
- }
+ NFFactory(NumberFormatFactory* delegate)
+ : LocaleKeyFactory(delegate->visible() ? VISIBLE : INVISIBLE)
+ , _delegate(delegate)
+ , _ids(NULL)
+ {
+ }
- 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();
+ virtual ~NFFactory();
- UObject* result = _delegate->createFormat(loc, (UNumberFormatStyle)(kind+1));
- if (result == NULL) {
- result = service->getKey((ICUServiceKey&)key /* cast away const */, NULL, this, status);
- }
- return result;
+ 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;
}
- 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 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 _ids;
+ return NULL;
}
- return NULL;
- }
};
+NFFactory::~NFFactory()
+{
+ delete _delegate;
+ delete _ids;
+}
+
class ICUNumberFormatService : public ICULocaleService {
public:
- ICUNumberFormatService()
- : ICULocaleService("Number Format")
- {
- UErrorCode status = U_ZERO_ERROR;
- registerFactory(new ICUNumberFormatFactory(), status);
- }
+ ICUNumberFormatService()
+ : ICULocaleService(UNICODE_STRING_SIMPLE("Number Format"))
+ {
+ UErrorCode status = U_ZERO_ERROR;
+ registerFactory(new ICUNumberFormatFactory(), status);
+ }
- virtual UObject* cloneInstance(UObject* instance) const {
- return ((NumberFormat*)instance)->clone();
- }
+ virtual ~ICUNumberFormatService();
- 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, (NumberFormat::EStyles)kind, status);
- }
+ virtual UObject* cloneInstance(UObject* instance) const {
+ return ((NumberFormat*)instance)->clone();
+ }
- virtual UBool isDefault() const {
- return countFactories() == 1;
- }
+ 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 ICULocaleService*
-getService(void)
-{
- UBool needInit;
- {
- Mutex mutex;
- needInit = (UBool)(gService == NULL);
- }
- if (needInit) {
- ICULocaleService * newservice = new ICUNumberFormatService();
- if (newservice) {
- Mutex mutex;
- if (gService == NULL) {
- gService = newservice;
- newservice = NULL;
- }
- }
- if (newservice) {
- delete newservice;
- } else {
- // we won the contention, this thread can register cleanup.
- ucln_i18n_registerCleanup();
- }
- }
- return gService;
+static void U_CALLCONV initNumberFormatService() {
+ U_ASSERT(gService == NULL);
+ ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup);
+ gService = new ICUNumberFormatService();
}
-// -------------------------------------
-
-NumberFormat*
-NumberFormat::createInstance(const Locale& loc, EStyles kind, UErrorCode& status)
+static ICULocaleService*
+getNumberFormatService(void)
{
- umtx_lock(NULL);
- UBool haveService = gService != NULL;
- umtx_unlock(NULL);
- if (haveService) {
- return (NumberFormat*)gService->get(loc, kind, status);
- } else {
- return makeInstance(loc, kind, status);
- }
+ umtx_initOnce(gServiceInitOnce, &initNumberFormatService);
+ return gService;
}
+static UBool haveService() {
+ return !gServiceInitOnce.isReset() && (getNumberFormatService() != NULL);
+}
// -------------------------------------
-URegistryKey
+URegistryKey U_EXPORT2
NumberFormat::registerFactory(NumberFormatFactory* toAdopt, UErrorCode& status)
{
- ICULocaleService *service = getService();
+ ICULocaleService *service = getNumberFormatService();
if (service) {
- return service->registerFactory(new NFFactory(toAdopt), status);
+ NFFactory *tempnnf = new NFFactory(toAdopt);
+ if (tempnnf != NULL) {
+ return service->registerFactory(tempnnf, status);
+ }
}
status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
// -------------------------------------
-UBool
+UBool U_EXPORT2
NumberFormat::unregister(URegistryKey key, UErrorCode& status)
{
- if (U_SUCCESS(status)) {
- umtx_lock(NULL);
- UBool haveService = gService != NULL;
- umtx_unlock(NULL);
- if (haveService) {
- return gService->unregister(key, status);
- }
+ if (U_FAILURE(status)) {
+ return FALSE;
+ }
+ if (haveService()) {
+ return gService->unregister(key, status);
+ } else {
status = U_ILLEGAL_ARGUMENT_ERROR;
+ return FALSE;
}
- return FALSE;
}
// -------------------------------------
-StringEnumeration*
+StringEnumeration* U_EXPORT2
NumberFormat::getAvailableLocales(void)
{
- ICULocaleService *service = getService();
+ ICULocaleService *service = getNumberFormatService();
if (service) {
- return service->getAvailableLocales();
+ 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<NumberFormat *>((*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
void
NumberFormat::setMaximumIntegerDigits(int32_t newValue)
{
- fMaxIntegerDigits = uprv_max(0, uprv_min(newValue, fgMaxIntegerDigits));
+ fMaxIntegerDigits = uprv_max(0, uprv_min(newValue, gDefaultMaxIntegerDigits));
if(fMinIntegerDigits > fMaxIntegerDigits)
fMinIntegerDigits = fMaxIntegerDigits;
}
void
NumberFormat::setMinimumIntegerDigits(int32_t newValue)
{
- fMinIntegerDigits = uprv_max(0, uprv_min(newValue, fgMinIntegerDigits));
+ fMinIntegerDigits = uprv_max(0, uprv_min(newValue, gDefaultMinIntegerDigits));
if(fMinIntegerDigits > fMaxIntegerDigits)
fMaxIntegerDigits = fMinIntegerDigits;
}
void
NumberFormat::setMaximumFractionDigits(int32_t newValue)
{
- fMaxFractionDigits = uprv_max(0, uprv_min(newValue, fgMaxIntegerDigits));
+ fMaxFractionDigits = uprv_max(0, uprv_min(newValue, gDefaultMaxIntegerDigits));
if(fMaxFractionDigits < fMinFractionDigits)
fMinFractionDigits = fMaxFractionDigits;
}
void
NumberFormat::setMinimumFractionDigits(int32_t newValue)
{
- fMinFractionDigits = uprv_max(0, uprv_min(newValue, fgMinIntegerDigits));
+ fMinFractionDigits = uprv_max(0, uprv_min(newValue, gDefaultMinIntegerDigits));
if (fMaxFractionDigits < fMinFractionDigits)
fMaxFractionDigits = fMinFractionDigits;
}
// -------------------------------------
-void NumberFormat::setCurrency(const UChar* theCurrency) {
+void NumberFormat::setCurrency(const UChar* theCurrency, UErrorCode& ec) {
+ if (U_FAILURE(ec)) {
+ return;
+ }
if (theCurrency) {
- u_strncpy(currency, theCurrency, 3);
- currency[3] = 0;
+ 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 {
- currency[0] = 0;
+ const char* loc = getLocaleID(ULOC_VALID_LOCALE, ec);
+ if (loc == NULL) {
+ loc = uloc_getDefault();
+ }
+ ucurr_forLocale(loc, result, 4, &ec);
}
}
-const UChar* NumberFormat::getCurrency() const {
- return currency;
+//----------------------------------------------------------------------
+
+
+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<SharedNumberFormat>::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,
- EStyles style,
- UErrorCode& status)
-{
+ 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 >= kStyleCount) {
+ if (style < 0 || style >= UNUM_FORMAT_STYLE_COUNT) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return NULL;
}
- ResourceBundle resource((char *)0, desiredLocale, status);
- NumberFormat* f;
-
- if (U_FAILURE(status))
- {
- // We don't appear to have resource data available -- use the last-resort data
- status = U_USING_FALLBACK_WARNING;
-
- // Use the DecimalFormatSymbols constructor which uses last-resort data
- DecimalFormatSymbols* symbolsToAdopt = new DecimalFormatSymbols(status);
- if (symbolsToAdopt == NULL) {
- status = U_MEMORY_ALLOCATION_ERROR;
- return NULL;
- }
- if (U_FAILURE(status)) {
- delete symbolsToAdopt; // This should never happen
- 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;
+ }
- // Creates a DecimalFormat instance with the last resort number patterns.
- f = new DecimalFormat(fgLastResortNumberPatterns[style], symbolsToAdopt, status);
- if (f == NULL) {
- status = U_MEMORY_ALLOCATION_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<Win32NumberFormat> f(new Win32NumberFormat(desiredLocale, curr, status), status);
+ if (U_SUCCESS(status)) {
+ return f.orphan();
+ }
+ }
+ break;
+ default:
+ break;
+ }
}
- if (U_FAILURE(status)) {
- delete f;
- f = NULL;
+ }
+#endif
+ // Use numbering system cache hashtable
+ umtx_initOnce(gNSCacheInitOnce, &nscacheInit);
+
+ // Get cached numbering system
+ LocalPointer<NumberingSystem> ownedNs;
+ NumberingSystem *ns = NULL;
+ if (NumberingSystem_cache != NULL) {
+ // TODO: Bad hash key usage, see ticket #8504.
+ int32_t hashKey = desiredLocale.hashCode();
+
+ static UMutex *nscacheMutex = STATIC_NEW(UMutex);
+ 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);
}
- return f;
+ } else {
+ ownedNs.adoptInstead(NumberingSystem::createInstance(desiredLocale,status));
+ ns = ownedNs.getAlias();
}
- ResourceBundle numberPatterns(resource.get(DecimalFormat::fgNumberPatterns, status));
- // If not all the styled patterns exists for the NumberFormat in this locale,
- // sets the status code to failure and returns nil.
- //if (patternCount < fgNumberPatternsCount) status = U_INVALID_FORMAT_ERROR;
- if (numberPatterns.getSize() < fgNumberPatternsCount)
- status = U_INVALID_FORMAT_ERROR;
- if (U_FAILURE(status))
+ // check results of getting a numbering system
+ if (U_FAILURE(status)) {
return NULL;
+ }
- // Loads the decimal symbols of the desired locale.
- DecimalFormatSymbols* symbolsToAdopt = new DecimalFormatSymbols(desiredLocale, status);
- if (symbolsToAdopt == NULL) {
- status = U_MEMORY_ALLOCATION_ERROR;
+ if (mustBeDecimalFormat && ns->isAlgorithmic()) {
+ status = U_UNSUPPORTED_ERROR;
return NULL;
}
+
+ LocalPointer<DecimalFormatSymbols> symbolsToAdopt;
+ UnicodeString pattern;
+ LocalUResourceBundlePointer ownedResource(ures_open(NULL, desiredLocale.getName(), &status));
if (U_FAILURE(status)) {
- delete symbolsToAdopt;
return NULL;
}
-
- // Creates the specified decimal format style of the desired locale.
- if (style < numberPatterns.getSize()) {
- const UnicodeString pattern(numberPatterns.getStringEx(style, status));
- if (U_SUCCESS(status)) {
- f = new DecimalFormat(pattern, symbolsToAdopt, status);
+ else {
+ // Loads the decimal symbols of the desired locale.
+ if (ns != nullptr) {
+ // Apple <rdar://51672521> use the ns we already have, so DecimalFormatSymbols does not instantiate another
+ symbolsToAdopt.adoptInsteadAndCheckErrorCode(new DecimalFormatSymbols(desiredLocale, *ns, status), status);
+ } else {
+ symbolsToAdopt.adoptInsteadAndCheckErrorCode(new DecimalFormatSymbols(desiredLocale, status), status);
}
- else {
+ 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);
}
- else {
- // If the requested style doesn't exist, use a last-resort style.
- // This is to support scientific styles before we have all the
- // resource data in place.
- f = new DecimalFormat(fgLastResortNumberPatterns[style], symbolsToAdopt, status);
+ 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));
+ }
}
- if (f == NULL) {
- status = U_MEMORY_ALLOCATION_ERROR;
- return NULL;
+ LocalPointer<NumberFormat> 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<DecimalFormat> 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)) {
- delete f;
- f = NULL;
+ return NULL;
}
- return f;
+ return f.orphan();
}
-U_NAMESPACE_END
-
-// defined in ucln_cmn.h
+/**
+ * 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;
+}
/**
- * Release all static memory held by numberformat.
+ * Set the rounding mode. This has no effect unless the rounding
+ * increment is greater than zero.
+ * @param roundingMode A rounding mode
*/
-U_CFUNC UBool numfmt_cleanup(void) {
- if (gService) {
- delete gService;
- gService = NULL;
- }
- return TRUE;
+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
projects / apple / icu.git / blobdiff