1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4*******************************************************************************
5* Copyright (C) 1997-2015, International Business Machines Corporation and
6* others. All Rights Reserved.
7*******************************************************************************
8*
9* File NUMFMT.CPP
10*
11* Modification History:
12*
13* Date Name Description
14* 02/19/97 aliu Converted from java.
15* 03/18/97 clhuang Implemented with C++ APIs.
16* 04/17/97 aliu Enlarged MAX_INTEGER_DIGITS to fully accomodate the
17* largest double, by default.
18* Changed DigitCount to int per code review.
19* 07/20/98 stephen Changed operator== to check for grouping
20* Changed setMaxIntegerDigits per Java implementation.
21* Changed setMinIntegerDigits per Java implementation.
22* Changed setMinFractionDigits per Java implementation.
23* Changed setMaxFractionDigits per Java implementation.
24********************************************************************************
25*/
26
27#include "unicode/utypes.h"
28
29#if !UCONFIG_NO_FORMATTING
30
31#include "unicode/numfmt.h"
32#include "unicode/locid.h"
33#include "unicode/dcfmtsym.h"
34#include "unicode/decimfmt.h"
35#include "unicode/ustring.h"
36#include "unicode/ucurr.h"
37#include "unicode/curramt.h"
38#include "unicode/numsys.h"
39#include "unicode/rbnf.h"
40#include "unicode/localpointer.h"
41#include "unicode/udisplaycontext.h"
42#include "charstr.h"
43#include "winnmfmt.h"
44#include "uresimp.h"
45#include "uhash.h"
46#include "cmemory.h"
47#include "servloc.h"
48#include "ucln_in.h"
49#include "cstring.h"
50#include "putilimp.h"
51#include "uassert.h"
52#include "umutex.h"
53#include "mutex.h"
54#include <float.h>
55#include "sharednumberformat.h"
56#include "unifiedcache.h"
57#include "number_decimalquantity.h"
58#include "number_utils.h"
59
60//#define FMT_DEBUG
61
62#ifdef FMT_DEBUG
63#include <stdio.h>
64static inline void debugout(UnicodeString s) {
65 char buf[2000];
66 s.extract((int32_t) 0, s.length(), buf);
67 printf("%s", buf);
68}
69#define debug(x) printf("%s", x);
70#else
71#define debugout(x)
72#define debug(x)
73#endif
74
75// If no number pattern can be located for a locale, this is the last
76// resort. The patterns are same as the ones in root locale.
77static const UChar gLastResortDecimalPat[] = {
78 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0 /* "#,##0.###" */
79};
80static const UChar gLastResortCurrencyPat[] = {
81 0xA4, 0xA0, 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x30, 0x30, 0 /* "\u00A4\u00A0#,##0.00" */
82};
83static const UChar gLastResortPercentPat[] = {
84 0x23, 0x2C, 0x23, 0x23, 0x30, 0x25, 0 /* "#,##0%" */
85};
86static const UChar gLastResortScientificPat[] = {
87 0x23, 0x45, 0x30, 0 /* "#E0" */
88};
89static const UChar gLastResortIsoCurrencyPat[] = {
90 0xA4, 0xA4, 0xA0, 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x30, 0x30, 0 /* "\u00A4\u00A4\u00A0#,##0.00" */
91};
92static const UChar gLastResortPluralCurrencyPat[] = {
93 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0x20, 0xA4, 0xA4, 0xA4, 0 /* "#,##0.### \u00A4\u00A4\u00A4*/
94};
95static const UChar gLastResortAccountingCurrencyPat[] = {
96 0xA4, 0xA0, 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x30, 0x30, 0 /* "\u00A4\u00A0#,##0.00" */
97};
98
99static const UChar gSingleCurrencySign[] = {0xA4, 0};
100static const UChar gDoubleCurrencySign[] = {0xA4, 0xA4, 0};
101
102static const UChar gSlash = 0x2f;
103
104// If the maximum base 10 exponent were 4, then the largest number would
105// be 99,999 which has 5 digits.
106// On IEEE754 systems gMaxIntegerDigits is 308 + possible denormalized 15 digits + rounding digit
107// With big decimal, the max exponent is 999,999,999 and the max number of digits is the same, 999,999,999
108const int32_t icu::NumberFormat::gDefaultMaxIntegerDigits = 2000000000;
109const int32_t icu::NumberFormat::gDefaultMinIntegerDigits = 127;
110
111static const UChar * const gLastResortNumberPatterns[UNUM_FORMAT_STYLE_COUNT] = {
112 NULL, // UNUM_PATTERN_DECIMAL
113 gLastResortDecimalPat, // UNUM_DECIMAL
114 gLastResortCurrencyPat, // UNUM_CURRENCY
115 gLastResortPercentPat, // UNUM_PERCENT
116 gLastResortScientificPat, // UNUM_SCIENTIFIC
117 NULL, // UNUM_SPELLOUT
118 NULL, // UNUM_ORDINAL
119 NULL, // UNUM_DURATION
120 NULL, // UNUM_NUMBERING_SYSTEM
121 NULL, // UNUM_PATTERN_RULEBASED
122 gLastResortIsoCurrencyPat, // UNUM_CURRENCY_ISO
123 gLastResortPluralCurrencyPat, // UNUM_CURRENCY_PLURAL
124 gLastResortAccountingCurrencyPat, // UNUM_CURRENCY_ACCOUNTING
125 gLastResortCurrencyPat, // UNUM_CASH_CURRENCY
126 NULL, // UNUM_DECIMAL_COMPACT_SHORT
127 NULL, // UNUM_DECIMAL_COMPACT_LONG
128 gLastResortCurrencyPat, // UNUM_CURRENCY_STANDARD
129};
130
131// Keys used for accessing resource bundles
132
133static const icu::number::impl::CldrPatternStyle gFormatCldrStyles[UNUM_FORMAT_STYLE_COUNT] = {
134 /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_PATTERN_DECIMAL
135 icu::number::impl::CLDR_PATTERN_STYLE_DECIMAL, // UNUM_DECIMAL
136 icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY, // UNUM_CURRENCY
137 icu::number::impl::CLDR_PATTERN_STYLE_PERCENT, // UNUM_PERCENT
138 icu::number::impl::CLDR_PATTERN_STYLE_SCIENTIFIC, // UNUM_SCIENTIFIC
139 /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_SPELLOUT
140 /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_ORDINAL
141 /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_DURATION
142 /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_NUMBERING_SYSTEM
143 /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_PATTERN_RULEBASED
144 // For UNUM_CURRENCY_ISO and UNUM_CURRENCY_PLURAL,
145 // the pattern is the same as the pattern of UNUM_CURRENCY
146 // except for replacing the single currency sign with
147 // double currency sign or triple currency sign.
148 icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY, // UNUM_CURRENCY_ISO
149 icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY, // UNUM_CURRENCY_PLURAL
150 icu::number::impl::CLDR_PATTERN_STYLE_ACCOUNTING, // UNUM_CURRENCY_ACCOUNTING
151 icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY, // UNUM_CASH_CURRENCY
152 /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_DECIMAL_COMPACT_SHORT
153 /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_DECIMAL_COMPACT_LONG
154 icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY, // UNUM_CURRENCY_STANDARD
155};
156
157// Static hashtable cache of NumberingSystem objects used by NumberFormat
158static UHashtable * NumberingSystem_cache = NULL;
159static icu::UInitOnce gNSCacheInitOnce = U_INITONCE_INITIALIZER;
160
161#if !UCONFIG_NO_SERVICE
162static icu::ICULocaleService* gService = NULL;
163static icu::UInitOnce gServiceInitOnce = U_INITONCE_INITIALIZER;
164#endif
165
166/**
167 * Release all static memory held by Number Format.
168 */
169U_CDECL_BEGIN
170static void U_CALLCONV
171deleteNumberingSystem(void *obj) {
172 delete (icu::NumberingSystem *)obj;
173}
174
175static UBool U_CALLCONV numfmt_cleanup(void) {
176#if !UCONFIG_NO_SERVICE
177 gServiceInitOnce.reset();
178 if (gService) {
179 delete gService;
180 gService = NULL;
181 }
182#endif
183 gNSCacheInitOnce.reset();
184 if (NumberingSystem_cache) {
185 // delete NumberingSystem_cache;
186 uhash_close(NumberingSystem_cache);
187 NumberingSystem_cache = NULL;
188 }
189 return TRUE;
190}
191U_CDECL_END
192
193// *****************************************************************************
194// class NumberFormat
195// *****************************************************************************
196
197U_NAMESPACE_BEGIN
198
199UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(NumberFormat)
200
201#if !UCONFIG_NO_SERVICE
202// -------------------------------------
203// SimpleNumberFormatFactory implementation
204NumberFormatFactory::~NumberFormatFactory() {}
205SimpleNumberFormatFactory::SimpleNumberFormatFactory(const Locale& locale, UBool visible)
206 : _visible(visible)
207{
208 LocaleUtility::initNameFromLocale(locale, _id);
209}
210
211SimpleNumberFormatFactory::~SimpleNumberFormatFactory() {}
212
213UBool SimpleNumberFormatFactory::visible(void) const {
214 return _visible;
215}
216
217const UnicodeString *
218SimpleNumberFormatFactory::getSupportedIDs(int32_t &count, UErrorCode& status) const
219{
220 if (U_SUCCESS(status)) {
221 count = 1;
222 return &_id;
223 }
224 count = 0;
225 return NULL;
226}
227#endif /* #if !UCONFIG_NO_SERVICE */
228
229// -------------------------------------
230// default constructor
231NumberFormat::NumberFormat()
232: fGroupingUsed(TRUE),
233 fMaxIntegerDigits(gDefaultMaxIntegerDigits),
234 fMinIntegerDigits(1),
235 fMaxFractionDigits(3), // invariant, >= minFractionDigits
236 fMinFractionDigits(0),
237 fParseIntegerOnly(FALSE),
238 fLenient(FALSE),
239 fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
240{
241 fCurrency[0] = 0;
242}
243
244// -------------------------------------
245
246NumberFormat::~NumberFormat()
247{
248}
249
250SharedNumberFormat::~SharedNumberFormat() {
251 delete ptr;
252}
253
254// -------------------------------------
255// copy constructor
256
257NumberFormat::NumberFormat(const NumberFormat &source)
258: Format(source)
259{
260 *this = source;
261}
262
263// -------------------------------------
264// assignment operator
265
266NumberFormat&
267NumberFormat::operator=(const NumberFormat& rhs)
268{
269 if (this != &rhs)
270 {
271 Format::operator=(rhs);
272 fGroupingUsed = rhs.fGroupingUsed;
273 fMaxIntegerDigits = rhs.fMaxIntegerDigits;
274 fMinIntegerDigits = rhs.fMinIntegerDigits;
275 fMaxFractionDigits = rhs.fMaxFractionDigits;
276 fMinFractionDigits = rhs.fMinFractionDigits;
277 fParseIntegerOnly = rhs.fParseIntegerOnly;
278 u_strncpy(fCurrency, rhs.fCurrency, 3);
279 fCurrency[3] = 0;
280 fLenient = rhs.fLenient;
281 fCapitalizationContext = rhs.fCapitalizationContext;
282 }
283 return *this;
284}
285
286// -------------------------------------
287
288UBool
289NumberFormat::operator==(const Format& that) const
290{
291 // Format::operator== guarantees this cast is safe
292 NumberFormat* other = (NumberFormat*)&that;
293
294#ifdef FMT_DEBUG
295 // This code makes it easy to determine why two format objects that should
296 // be equal aren't.
297 UBool first = TRUE;
298 if (!Format::operator==(that)) {
299 if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
300 debug("Format::!=");
301 }
302 if (!(fMaxIntegerDigits == other->fMaxIntegerDigits &&
303 fMinIntegerDigits == other->fMinIntegerDigits)) {
304 if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
305 debug("Integer digits !=");
306 }
307 if (!(fMaxFractionDigits == other->fMaxFractionDigits &&
308 fMinFractionDigits == other->fMinFractionDigits)) {
309 if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
310 debug("Fraction digits !=");
311 }
312 if (!(fGroupingUsed == other->fGroupingUsed)) {
313 if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
314 debug("fGroupingUsed != ");
315 }
316 if (!(fParseIntegerOnly == other->fParseIntegerOnly)) {
317 if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
318 debug("fParseIntegerOnly != ");
319 }
320 if (!(u_strcmp(fCurrency, other->fCurrency) == 0)) {
321 if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
322 debug("fCurrency !=");
323 }
324 if (!(fLenient == other->fLenient)) {
325 if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
326 debug("fLenient != ");
327 }
328 if (!(fCapitalizationContext == other->fCapitalizationContext)) {
329 if (first) { printf("[ "); first = FALSE; } else { printf(", "); }
330 debug("fCapitalizationContext != ");
331 }
332 if (!first) { printf(" ]"); }
333#endif
334
335 return ((this == &that) ||
336 ((Format::operator==(that) &&
337 fMaxIntegerDigits == other->fMaxIntegerDigits &&
338 fMinIntegerDigits == other->fMinIntegerDigits &&
339 fMaxFractionDigits == other->fMaxFractionDigits &&
340 fMinFractionDigits == other->fMinFractionDigits &&
341 fGroupingUsed == other->fGroupingUsed &&
342 fParseIntegerOnly == other->fParseIntegerOnly &&
343 u_strcmp(fCurrency, other->fCurrency) == 0 &&
344 fLenient == other->fLenient &&
345 fCapitalizationContext == other->fCapitalizationContext)));
346}
347
348// -------------------------------------
349// Default implementation sets unsupported error; subclasses should
350// override.
351
352UnicodeString&
353NumberFormat::format(double /* unused number */,
354 UnicodeString& toAppendTo,
355 FieldPositionIterator* /* unused posIter */,
356 UErrorCode& status) const
357{
358 if (!U_FAILURE(status)) {
359 status = U_UNSUPPORTED_ERROR;
360 }
361 return toAppendTo;
362}
363
364// -------------------------------------
365// Default implementation sets unsupported error; subclasses should
366// override.
367
368UnicodeString&
369NumberFormat::format(int32_t /* unused number */,
370 UnicodeString& toAppendTo,
371 FieldPositionIterator* /* unused posIter */,
372 UErrorCode& status) const
373{
374 if (!U_FAILURE(status)) {
375 status = U_UNSUPPORTED_ERROR;
376 }
377 return toAppendTo;
378}
379
380// -------------------------------------
381// Default implementation sets unsupported error; subclasses should
382// override.
383
384UnicodeString&
385NumberFormat::format(int64_t /* unused number */,
386 UnicodeString& toAppendTo,
387 FieldPositionIterator* /* unused posIter */,
388 UErrorCode& status) const
389{
390 if (!U_FAILURE(status)) {
391 status = U_UNSUPPORTED_ERROR;
392 }
393 return toAppendTo;
394}
395
396// ------------------------------------------
397// These functions add the status code, just fall back to the non-status versions
398UnicodeString&
399NumberFormat::format(double number,
400 UnicodeString& appendTo,
401 FieldPosition& pos,
402 UErrorCode &status) const {
403 if(U_SUCCESS(status)) {
404 return format(number,appendTo,pos);
405 } else {
406 return appendTo;
407 }
408}
409
410UnicodeString&
411NumberFormat::format(int32_t number,
412 UnicodeString& appendTo,
413 FieldPosition& pos,
414 UErrorCode &status) const {
415 if(U_SUCCESS(status)) {
416 return format(number,appendTo,pos);
417 } else {
418 return appendTo;
419 }
420}
421
422UnicodeString&
423NumberFormat::format(int64_t number,
424 UnicodeString& appendTo,
425 FieldPosition& pos,
426 UErrorCode &status) const {
427 if(U_SUCCESS(status)) {
428 return format(number,appendTo,pos);
429 } else {
430 return appendTo;
431 }
432}
433
434
435
436// -------------------------------------
437// Decimal Number format() default implementation
438// Subclasses do not normally override this function, but rather the DigitList
439// formatting functions..
440// The expected call chain from here is
441// this function ->
442// NumberFormat::format(Formattable ->
443// DecimalFormat::format(DigitList
444//
445// Or, for subclasses of Formattable that do not know about DigitList,
446// this Function ->
447// NumberFormat::format(Formattable ->
448// NumberFormat::format(DigitList ->
449// XXXFormat::format(double
450
451UnicodeString&
452NumberFormat::format(StringPiece decimalNum,
453 UnicodeString& toAppendTo,
454 FieldPositionIterator* fpi,
455 UErrorCode& status) const
456{
457 Formattable f;
458 f.setDecimalNumber(decimalNum, status);
459 format(f, toAppendTo, fpi, status);
460 return toAppendTo;
461}
462
463/**
464 *
465// Formats the number object and save the format
466// result in the toAppendTo string buffer.
467
468// utility to save/restore state, used in two overloads
469// of format(const Formattable&...) below.
470*
471* Old purpose of ArgExtractor was to avoid const. Not thread safe!
472*
473* keeping it around as a shim.
474*/
475class ArgExtractor {
476 const Formattable* num;
477 UChar save[4];
478 UBool fWasCurrency;
479
480 public:
481 ArgExtractor(const NumberFormat& nf, const Formattable& obj, UErrorCode& status);
482 ~ArgExtractor();
483
484 const Formattable* number(void) const;
485 const UChar *iso(void) const;
486 UBool wasCurrency(void) const;
487};
488
489inline const Formattable*
490ArgExtractor::number(void) const {
491 return num;
492}
493
494inline UBool
495ArgExtractor::wasCurrency(void) const {
496 return fWasCurrency;
497}
498
499inline const UChar *
500ArgExtractor::iso(void) const {
501 return save;
502}
503
504ArgExtractor::ArgExtractor(const NumberFormat& /*nf*/, const Formattable& obj, UErrorCode& /*status*/)
505 : num(&obj), fWasCurrency(FALSE) {
506
507 const UObject* o = obj.getObject(); // most commonly o==NULL
508 const CurrencyAmount* amt;
509 if (o != NULL && (amt = dynamic_cast<const CurrencyAmount*>(o)) != NULL) {
510 // getISOCurrency() returns a pointer to internal storage, so we
511 // copy it to retain it across the call to setCurrency().
512 //const UChar* curr = amt->getISOCurrency();
513 u_strcpy(save, amt->getISOCurrency());
514 num = &amt->getNumber();
515 fWasCurrency=TRUE;
516 } else {
517 save[0]=0;
518 }
519}
520
521ArgExtractor::~ArgExtractor() {
522}
523
524UnicodeString& NumberFormat::format(const number::impl::DecimalQuantity &number,
525 UnicodeString& appendTo,
526 FieldPositionIterator* posIter,
527 UErrorCode& status) const {
528 // DecimalFormat overrides this function, and handles DigitList based big decimals.
529 // Other subclasses (ChoiceFormat) do not (yet) handle DigitLists,
530 // so this default implementation falls back to formatting decimal numbers as doubles.
531 if (U_FAILURE(status)) {
532 return appendTo;
533 }
534 double dnum = number.toDouble();
535 format(dnum, appendTo, posIter, status);
536 return appendTo;
537}
538
539
540
541UnicodeString&
542NumberFormat::format(const number::impl::DecimalQuantity &number,
543 UnicodeString& appendTo,
544 FieldPosition& pos,
545 UErrorCode &status) const {
546 // DecimalFormat overrides this function, and handles DigitList based big decimals.
547 // Other subclasses (ChoiceFormat) do not (yet) handle DigitLists,
548 // so this default implementation falls back to formatting decimal numbers as doubles.
549 if (U_FAILURE(status)) {
550 return appendTo;
551 }
552 double dnum = number.toDouble();
553 format(dnum, appendTo, pos, status);
554 return appendTo;
555}
556
557UnicodeString&
558NumberFormat::format(const Formattable& obj,
559 UnicodeString& appendTo,
560 FieldPosition& pos,
561 UErrorCode& status) const
562{
563 if (U_FAILURE(status)) return appendTo;
564
565 ArgExtractor arg(*this, obj, status);
566 const Formattable *n = arg.number();
567 const UChar *iso = arg.iso();
568
569 if(arg.wasCurrency() && u_strcmp(iso, getCurrency())) {
570 // trying to format a different currency.
571 // Right now, we clone.
572 LocalPointer<NumberFormat> cloneFmt(this->clone());
573 cloneFmt->setCurrency(iso, status);
574 // next line should NOT recurse, because n is numeric whereas obj was a wrapper around currency amount.
575 return cloneFmt->format(*n, appendTo, pos, status);
576 }
577
578 if (n->isNumeric() && n->getDecimalQuantity() != NULL) {
579 // Decimal Number. We will have a DigitList available if the value was
580 // set to a decimal number, or if the value originated with a parse.
581 //
582 // The default implementation for formatting a DigitList converts it
583 // to a double, and formats that, allowing formatting classes that don't
584 // know about DigitList to continue to operate as they had.
585 //
586 // DecimalFormat overrides the DigitList formatting functions.
587 format(*n->getDecimalQuantity(), appendTo, pos, status);
588 } else {
589 switch (n->getType()) {
590 case Formattable::kDouble:
591 format(n->getDouble(), appendTo, pos, status);
592 break;
593 case Formattable::kLong:
594 format(n->getLong(), appendTo, pos, status);
595 break;
596 case Formattable::kInt64:
597 format(n->getInt64(), appendTo, pos, status);
598 break;
599 default:
600 status = U_INVALID_FORMAT_ERROR;
601 break;
602 }
603 }
604
605 return appendTo;
606}
607
608// -------------------------------------x
609// Formats the number object and save the format
610// result in the toAppendTo string buffer.
611
612UnicodeString&
613NumberFormat::format(const Formattable& obj,
614 UnicodeString& appendTo,
615 FieldPositionIterator* posIter,
616 UErrorCode& status) const
617{
618 if (U_FAILURE(status)) return appendTo;
619
620 ArgExtractor arg(*this, obj, status);
621 const Formattable *n = arg.number();
622 const UChar *iso = arg.iso();
623
624 if(arg.wasCurrency() && u_strcmp(iso, getCurrency())) {
625 // trying to format a different currency.
626 // Right now, we clone.
627 LocalPointer<NumberFormat> cloneFmt(this->clone());
628 cloneFmt->setCurrency(iso, status);
629 // next line should NOT recurse, because n is numeric whereas obj was a wrapper around currency amount.
630 return cloneFmt->format(*n, appendTo, posIter, status);
631 }
632
633 if (n->isNumeric() && n->getDecimalQuantity() != NULL) {
634 // Decimal Number
635 format(*n->getDecimalQuantity(), appendTo, posIter, status);
636 } else {
637 switch (n->getType()) {
638 case Formattable::kDouble:
639 format(n->getDouble(), appendTo, posIter, status);
640 break;
641 case Formattable::kLong:
642 format(n->getLong(), appendTo, posIter, status);
643 break;
644 case Formattable::kInt64:
645 format(n->getInt64(), appendTo, posIter, status);
646 break;
647 default:
648 status = U_INVALID_FORMAT_ERROR;
649 break;
650 }
651 }
652
653 return appendTo;
654}
655
656// -------------------------------------
657
658UnicodeString&
659NumberFormat::format(int64_t number,
660 UnicodeString& appendTo,
661 FieldPosition& pos) const
662{
663 // default so we don't introduce a new abstract method
664 return format((int32_t)number, appendTo, pos);
665}
666
667// -------------------------------------
668// Parses the string and save the result object as well
669// as the final parsed position.
670
671void
672NumberFormat::parseObject(const UnicodeString& source,
673 Formattable& result,
674 ParsePosition& parse_pos) const
675{
676 parse(source, result, parse_pos);
677}
678
679// -------------------------------------
680// Formats a double number and save the result in a string.
681
682UnicodeString&
683NumberFormat::format(double number, UnicodeString& appendTo) const
684{
685 FieldPosition pos(FieldPosition::DONT_CARE);
686 return format(number, appendTo, pos);
687}
688
689// -------------------------------------
690// Formats a long number and save the result in a string.
691
692UnicodeString&
693NumberFormat::format(int32_t number, UnicodeString& appendTo) const
694{
695 FieldPosition pos(FieldPosition::DONT_CARE);
696 return format(number, appendTo, pos);
697}
698
699// -------------------------------------
700// Formats a long number and save the result in a string.
701
702UnicodeString&
703NumberFormat::format(int64_t number, UnicodeString& appendTo) const
704{
705 FieldPosition pos(FieldPosition::DONT_CARE);
706 return format(number, appendTo, pos);
707}
708
709// -------------------------------------
710// Parses the text and save the result object. If the returned
711// parse position is 0, that means the parsing failed, the status
712// code needs to be set to failure. Ignores the returned parse
713// position, otherwise.
714
715void
716NumberFormat::parse(const UnicodeString& text,
717 Formattable& result,
718 UErrorCode& status) const
719{
720 if (U_FAILURE(status)) return;
721
722 ParsePosition parsePosition(0);
723 parse(text, result, parsePosition);
724 if (parsePosition.getIndex() == 0) {
725 status = U_INVALID_FORMAT_ERROR;
726 }
727}
728
729CurrencyAmount* NumberFormat::parseCurrency(const UnicodeString& text,
730 ParsePosition& pos) const {
731 // Default implementation only -- subclasses should override
732 Formattable parseResult;
733 int32_t start = pos.getIndex();
734 parse(text, parseResult, pos);
735 if (pos.getIndex() != start) {
736 UChar curr[4];
737 UErrorCode ec = U_ZERO_ERROR;
738 getEffectiveCurrency(curr, ec);
739 if (U_SUCCESS(ec)) {
740 LocalPointer<CurrencyAmount> currAmt(new CurrencyAmount(parseResult, curr, ec), ec);
741 if (U_FAILURE(ec)) {
742 pos.setIndex(start); // indicate failure
743 } else {
744 return currAmt.orphan();
745 }
746 }
747 }
748 return NULL;
749}
750
751// -------------------------------------
752// Sets to only parse integers.
753
754void
755NumberFormat::setParseIntegerOnly(UBool value)
756{
757 fParseIntegerOnly = value;
758}
759
760// -------------------------------------
761// Sets whether lenient parse is enabled.
762
763void
764NumberFormat::setLenient(UBool enable)
765{
766 fLenient = enable;
767}
768
769// -------------------------------------
770// Create a number style NumberFormat instance with the default locale.
771
772NumberFormat* U_EXPORT2
773NumberFormat::createInstance(UErrorCode& status)
774{
775 return createInstance(Locale::getDefault(), UNUM_DECIMAL, status);
776}
777
778// -------------------------------------
779// Create a number style NumberFormat instance with the inLocale locale.
780
781NumberFormat* U_EXPORT2
782NumberFormat::createInstance(const Locale& inLocale, UErrorCode& status)
783{
784 return createInstance(inLocale, UNUM_DECIMAL, status);
785}
786
787// -------------------------------------
788// Create a currency style NumberFormat instance with the default locale.
789
790NumberFormat* U_EXPORT2
791NumberFormat::createCurrencyInstance(UErrorCode& status)
792{
793 return createCurrencyInstance(Locale::getDefault(), status);
794}
795
796// -------------------------------------
797// Create a currency style NumberFormat instance with the inLocale locale.
798
799NumberFormat* U_EXPORT2
800NumberFormat::createCurrencyInstance(const Locale& inLocale, UErrorCode& status)
801{
802 return createInstance(inLocale, UNUM_CURRENCY, status);
803}
804
805// -------------------------------------
806// Create a percent style NumberFormat instance with the default locale.
807
808NumberFormat* U_EXPORT2
809NumberFormat::createPercentInstance(UErrorCode& status)
810{
811 return createInstance(Locale::getDefault(), UNUM_PERCENT, status);
812}
813
814// -------------------------------------
815// Create a percent style NumberFormat instance with the inLocale locale.
816
817NumberFormat* U_EXPORT2
818NumberFormat::createPercentInstance(const Locale& inLocale, UErrorCode& status)
819{
820 return createInstance(inLocale, UNUM_PERCENT, status);
821}
822
823// -------------------------------------
824// Create a scientific style NumberFormat instance with the default locale.
825
826NumberFormat* U_EXPORT2
827NumberFormat::createScientificInstance(UErrorCode& status)
828{
829 return createInstance(Locale::getDefault(), UNUM_SCIENTIFIC, status);
830}
831
832// -------------------------------------
833// Create a scientific style NumberFormat instance with the inLocale locale.
834
835NumberFormat* U_EXPORT2
836NumberFormat::createScientificInstance(const Locale& inLocale, UErrorCode& status)
837{
838 return createInstance(inLocale, UNUM_SCIENTIFIC, status);
839}
840
841// -------------------------------------
842
843const Locale* U_EXPORT2
844NumberFormat::getAvailableLocales(int32_t& count)
845{
846 return Locale::getAvailableLocales(count);
847}
848
849// ------------------------------------------
850//
851// Registration
852//
853//-------------------------------------------
854
855#if !UCONFIG_NO_SERVICE
856
857// -------------------------------------
858
859class ICUNumberFormatFactory : public ICUResourceBundleFactory {
860public:
861 virtual ~ICUNumberFormatFactory();
862protected:
863 virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /* service */, UErrorCode& status) const {
864 return NumberFormat::makeInstance(loc, (UNumberFormatStyle)kind, status);
865 }
866};
867
868ICUNumberFormatFactory::~ICUNumberFormatFactory() {}
869
870// -------------------------------------
871
872class NFFactory : public LocaleKeyFactory {
873private:
874 NumberFormatFactory* _delegate;
875 Hashtable* _ids;
876
877public:
878 NFFactory(NumberFormatFactory* delegate)
879 : LocaleKeyFactory(delegate->visible() ? VISIBLE : INVISIBLE)
880 , _delegate(delegate)
881 , _ids(NULL)
882 {
883 }
884
885 virtual ~NFFactory();
886
887 virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const
888 {
889 if (handlesKey(key, status)) {
890 const LocaleKey& lkey = (const LocaleKey&)key;
891 Locale loc;
892 lkey.canonicalLocale(loc);
893 int32_t kind = lkey.kind();
894
895 UObject* result = _delegate->createFormat(loc, (UNumberFormatStyle)kind);
896 if (result == NULL) {
897 result = service->getKey((ICUServiceKey&)key /* cast away const */, NULL, this, status);
898 }
899 return result;
900 }
901 return NULL;
902 }
903
904protected:
905 /**
906 * Return the set of ids that this factory supports (visible or
907 * otherwise). This can be called often and might need to be
908 * cached if it is expensive to create.
909 */
910 virtual const Hashtable* getSupportedIDs(UErrorCode& status) const
911 {
912 if (U_SUCCESS(status)) {
913 if (!_ids) {
914 int32_t count = 0;
915 const UnicodeString * const idlist = _delegate->getSupportedIDs(count, status);
916 ((NFFactory*)this)->_ids = new Hashtable(status); /* cast away const */
917 if (_ids) {
918 for (int i = 0; i < count; ++i) {
919 _ids->put(idlist[i], (void*)this, status);
920 }
921 }
922 }
923 return _ids;
924 }
925 return NULL;
926 }
927};
928
929NFFactory::~NFFactory()
930{
931 delete _delegate;
932 delete _ids;
933}
934
935class ICUNumberFormatService : public ICULocaleService {
936public:
937 ICUNumberFormatService()
938 : ICULocaleService(UNICODE_STRING_SIMPLE("Number Format"))
939 {
940 UErrorCode status = U_ZERO_ERROR;
941 registerFactory(new ICUNumberFormatFactory(), status);
942 }
943
944 virtual ~ICUNumberFormatService();
945
946 virtual UObject* cloneInstance(UObject* instance) const {
947 return ((NumberFormat*)instance)->clone();
948 }
949
950 virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /* actualID */, UErrorCode& status) const {
951 LocaleKey& lkey = (LocaleKey&)key;
952 int32_t kind = lkey.kind();
953 Locale loc;
954 lkey.currentLocale(loc);
955 return NumberFormat::makeInstance(loc, (UNumberFormatStyle)kind, status);
956 }
957
958 virtual UBool isDefault() const {
959 return countFactories() == 1;
960 }
961};
962
963ICUNumberFormatService::~ICUNumberFormatService() {}
964
965// -------------------------------------
966
967static void U_CALLCONV initNumberFormatService() {
968 U_ASSERT(gService == NULL);
969 ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup);
970 gService = new ICUNumberFormatService();
971}
972
973static ICULocaleService*
974getNumberFormatService(void)
975{
976 umtx_initOnce(gServiceInitOnce, &initNumberFormatService);
977 return gService;
978}
979
980static UBool haveService() {
981 return !gServiceInitOnce.isReset() && (getNumberFormatService() != NULL);
982}
983
984// -------------------------------------
985
986URegistryKey U_EXPORT2
987NumberFormat::registerFactory(NumberFormatFactory* toAdopt, UErrorCode& status)
988{
989 if (U_FAILURE(status)) {
990 delete toAdopt;
991 return nullptr;
992 }
993 ICULocaleService *service = getNumberFormatService();
994 if (service) {
995 NFFactory *tempnnf = new NFFactory(toAdopt);
996 if (tempnnf != NULL) {
997 return service->registerFactory(tempnnf, status);
998 }
999 }
1000 status = U_MEMORY_ALLOCATION_ERROR;
1001 return NULL;
1002}
1003
1004// -------------------------------------
1005
1006UBool U_EXPORT2
1007NumberFormat::unregister(URegistryKey key, UErrorCode& status)
1008{
1009 if (U_FAILURE(status)) {
1010 return FALSE;
1011 }
1012 if (haveService()) {
1013 return gService->unregister(key, status);
1014 } else {
1015 status = U_ILLEGAL_ARGUMENT_ERROR;
1016 return FALSE;
1017 }
1018}
1019
1020// -------------------------------------
1021StringEnumeration* U_EXPORT2
1022NumberFormat::getAvailableLocales(void)
1023{
1024 ICULocaleService *service = getNumberFormatService();
1025 if (service) {
1026 return service->getAvailableLocales();
1027 }
1028 return NULL; // no way to return error condition
1029}
1030#endif /* UCONFIG_NO_SERVICE */
1031// -------------------------------------
1032
1033enum { kKeyValueLenMax = 32 };
1034
1035NumberFormat*
1036NumberFormat::internalCreateInstance(const Locale& loc, UNumberFormatStyle kind, UErrorCode& status) {
1037 if (kind == UNUM_CURRENCY) {
1038 char cfKeyValue[kKeyValueLenMax] = {0};
1039 UErrorCode kvStatus = U_ZERO_ERROR;
1040 int32_t kLen = loc.getKeywordValue("cf", cfKeyValue, kKeyValueLenMax, kvStatus);
1041 if (U_SUCCESS(kvStatus) && kLen > 0 && uprv_strcmp(cfKeyValue,"account")==0) {
1042 kind = UNUM_CURRENCY_ACCOUNTING;
1043 }
1044 }
1045#if !UCONFIG_NO_SERVICE
1046 if (haveService()) {
1047 return (NumberFormat*)gService->get(loc, kind, status);
1048 }
1049#endif
1050 return makeInstance(loc, kind, status);
1051}
1052
1053NumberFormat* U_EXPORT2
1054NumberFormat::createInstance(const Locale& loc, UNumberFormatStyle kind, UErrorCode& status) {
1055 if (kind != UNUM_DECIMAL) {
1056 return internalCreateInstance(loc, kind, status);
1057 }
1058 const SharedNumberFormat *shared = createSharedInstance(loc, kind, status);
1059 if (U_FAILURE(status)) {
1060 return NULL;
1061 }
1062 NumberFormat *result = (*shared)->clone();
1063 shared->removeRef();
1064 if (result == NULL) {
1065 status = U_MEMORY_ALLOCATION_ERROR;
1066 }
1067 return result;
1068}
1069
1070
1071// -------------------------------------
1072// Checks if the thousand/10 thousand grouping is used in the
1073// NumberFormat instance.
1074
1075UBool
1076NumberFormat::isGroupingUsed() const
1077{
1078 return fGroupingUsed;
1079}
1080
1081// -------------------------------------
1082// Sets to use the thousand/10 thousand grouping in the
1083// NumberFormat instance.
1084
1085void
1086NumberFormat::setGroupingUsed(UBool newValue)
1087{
1088 fGroupingUsed = newValue;
1089}
1090
1091// -------------------------------------
1092// Gets the maximum number of digits for the integral part for
1093// this NumberFormat instance.
1094
1095int32_t NumberFormat::getMaximumIntegerDigits() const
1096{
1097 return fMaxIntegerDigits;
1098}
1099
1100// -------------------------------------
1101// Sets the maximum number of digits for the integral part for
1102// this NumberFormat instance.
1103
1104void
1105NumberFormat::setMaximumIntegerDigits(int32_t newValue)
1106{
1107 fMaxIntegerDigits = uprv_max(0, uprv_min(newValue, gDefaultMaxIntegerDigits));
1108 if(fMinIntegerDigits > fMaxIntegerDigits)
1109 fMinIntegerDigits = fMaxIntegerDigits;
1110}
1111
1112// -------------------------------------
1113// Gets the minimum number of digits for the integral part for
1114// this NumberFormat instance.
1115
1116int32_t
1117NumberFormat::getMinimumIntegerDigits() const
1118{
1119 return fMinIntegerDigits;
1120}
1121
1122// -------------------------------------
1123// Sets the minimum number of digits for the integral part for
1124// this NumberFormat instance.
1125
1126void
1127NumberFormat::setMinimumIntegerDigits(int32_t newValue)
1128{
1129 fMinIntegerDigits = uprv_max(0, uprv_min(newValue, gDefaultMinIntegerDigits));
1130 if(fMinIntegerDigits > fMaxIntegerDigits)
1131 fMaxIntegerDigits = fMinIntegerDigits;
1132}
1133
1134// -------------------------------------
1135// Gets the maximum number of digits for the fractional part for
1136// this NumberFormat instance.
1137
1138int32_t
1139NumberFormat::getMaximumFractionDigits() const
1140{
1141 return fMaxFractionDigits;
1142}
1143
1144// -------------------------------------
1145// Sets the maximum number of digits for the fractional part for
1146// this NumberFormat instance.
1147
1148void
1149NumberFormat::setMaximumFractionDigits(int32_t newValue)
1150{
1151 fMaxFractionDigits = uprv_max(0, uprv_min(newValue, gDefaultMaxIntegerDigits));
1152 if(fMaxFractionDigits < fMinFractionDigits)
1153 fMinFractionDigits = fMaxFractionDigits;
1154}
1155
1156// -------------------------------------
1157// Gets the minimum number of digits for the fractional part for
1158// this NumberFormat instance.
1159
1160int32_t
1161NumberFormat::getMinimumFractionDigits() const
1162{
1163 return fMinFractionDigits;
1164}
1165
1166// -------------------------------------
1167// Sets the minimum number of digits for the fractional part for
1168// this NumberFormat instance.
1169
1170void
1171NumberFormat::setMinimumFractionDigits(int32_t newValue)
1172{
1173 fMinFractionDigits = uprv_max(0, uprv_min(newValue, gDefaultMinIntegerDigits));
1174 if (fMaxFractionDigits < fMinFractionDigits)
1175 fMaxFractionDigits = fMinFractionDigits;
1176}
1177
1178// -------------------------------------
1179
1180void NumberFormat::setCurrency(const UChar* theCurrency, UErrorCode& ec) {
1181 if (U_FAILURE(ec)) {
1182 return;
1183 }
1184 if (theCurrency) {
1185 u_strncpy(fCurrency, theCurrency, 3);
1186 fCurrency[3] = 0;
1187 } else {
1188 fCurrency[0] = 0;
1189 }
1190}
1191
1192const char16_t* NumberFormat::getCurrency() const {
1193 return fCurrency;
1194}
1195
1196void NumberFormat::getEffectiveCurrency(UChar* result, UErrorCode& ec) const {
1197 const UChar* c = getCurrency();
1198 if (*c != 0) {
1199 u_strncpy(result, c, 3);
1200 result[3] = 0;
1201 } else {
1202 const char* loc = getLocaleID(ULOC_VALID_LOCALE, ec);
1203 if (loc == NULL) {
1204 loc = uloc_getDefault();
1205 }
1206 ucurr_forLocale(loc, result, 4, &ec);
1207 }
1208}
1209
1210//----------------------------------------------------------------------
1211
1212
1213void NumberFormat::setContext(UDisplayContext value, UErrorCode& status)
1214{
1215 if (U_FAILURE(status))
1216 return;
1217 if ( (UDisplayContextType)((uint32_t)value >> 8) == UDISPCTX_TYPE_CAPITALIZATION ) {
1218 fCapitalizationContext = value;
1219 } else {
1220 status = U_ILLEGAL_ARGUMENT_ERROR;
1221 }
1222}
1223
1224
1225UDisplayContext NumberFormat::getContext(UDisplayContextType type, UErrorCode& status) const
1226{
1227 if (U_FAILURE(status))
1228 return (UDisplayContext)0;
1229 if (type != UDISPCTX_TYPE_CAPITALIZATION) {
1230 status = U_ILLEGAL_ARGUMENT_ERROR;
1231 return (UDisplayContext)0;
1232 }
1233 return fCapitalizationContext;
1234}
1235
1236
1237// -------------------------------------
1238// Creates the NumberFormat instance of the specified style (number, currency,
1239// or percent) for the desired locale.
1240
1241static void U_CALLCONV nscacheInit() {
1242 U_ASSERT(NumberingSystem_cache == NULL);
1243 ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup);
1244 UErrorCode status = U_ZERO_ERROR;
1245 NumberingSystem_cache = uhash_open(uhash_hashLong,
1246 uhash_compareLong,
1247 NULL,
1248 &status);
1249 if (U_FAILURE(status)) {
1250 // Number Format code will run with no cache if creation fails.
1251 NumberingSystem_cache = NULL;
1252 return;
1253 }
1254 uhash_setValueDeleter(NumberingSystem_cache, deleteNumberingSystem);
1255}
1256
1257template<> U_I18N_API
1258const SharedNumberFormat *LocaleCacheKey<SharedNumberFormat>::createObject(
1259 const void * /*unused*/, UErrorCode &status) const {
1260 const char *localeId = fLoc.getName();
1261 NumberFormat *nf = NumberFormat::internalCreateInstance(
1262 localeId, UNUM_DECIMAL, status);
1263 if (U_FAILURE(status)) {
1264 return NULL;
1265 }
1266 SharedNumberFormat *result = new SharedNumberFormat(nf);
1267 if (result == NULL) {
1268 status = U_MEMORY_ALLOCATION_ERROR;
1269 delete nf;
1270 return NULL;
1271 }
1272 result->addRef();
1273 return result;
1274}
1275
1276const SharedNumberFormat* U_EXPORT2
1277NumberFormat::createSharedInstance(const Locale& loc, UNumberFormatStyle kind, UErrorCode& status) {
1278 if (U_FAILURE(status)) {
1279 return NULL;
1280 }
1281 if (kind != UNUM_DECIMAL) {
1282 status = U_UNSUPPORTED_ERROR;
1283 return NULL;
1284 }
1285 const SharedNumberFormat *result = NULL;
1286 UnifiedCache::getByLocale(loc, result, status);
1287 return result;
1288}
1289
1290UBool
1291NumberFormat::isStyleSupported(UNumberFormatStyle style) {
1292 return gLastResortNumberPatterns[style] != NULL;
1293}
1294
1295NumberFormat*
1296NumberFormat::makeInstance(const Locale& desiredLocale,
1297 UNumberFormatStyle style,
1298 UErrorCode& status) {
1299 return makeInstance(desiredLocale, style, false, status);
1300}
1301
1302NumberFormat*
1303NumberFormat::makeInstance(const Locale& desiredLocale,
1304 UNumberFormatStyle style,
1305 UBool mustBeDecimalFormat,
1306 UErrorCode& status) {
1307 if (U_FAILURE(status)) return NULL;
1308
1309 if (style < 0 || style >= UNUM_FORMAT_STYLE_COUNT) {
1310 status = U_ILLEGAL_ARGUMENT_ERROR;
1311 return NULL;
1312 }
1313
1314 // Some styles are not supported. This is a result of merging
1315 // the @draft ICU 4.2 NumberFormat::EStyles into the long-existing UNumberFormatStyle.
1316 // Ticket #8503 is for reviewing/fixing/merging the two relevant implementations:
1317 // this one and unum_open().
1318 // The UNUM_PATTERN_ styles are not supported here
1319 // because this method does not take a pattern string.
1320 if (!isStyleSupported(style)) {
1321 status = U_UNSUPPORTED_ERROR;
1322 return NULL;
1323 }
1324
1325#if U_PLATFORM_USES_ONLY_WIN32_API
1326 if (!mustBeDecimalFormat) {
1327 char buffer[8];
1328 int32_t count = desiredLocale.getKeywordValue("compat", buffer, sizeof(buffer), status);
1329
1330 // if the locale has "@compat=host", create a host-specific NumberFormat
1331 if (U_SUCCESS(status) && count > 0 && uprv_strcmp(buffer, "host") == 0) {
1332 UBool curr = TRUE;
1333
1334 switch (style) {
1335 case UNUM_DECIMAL:
1336 curr = FALSE;
1337 // fall-through
1338 U_FALLTHROUGH;
1339
1340 case UNUM_CURRENCY:
1341 case UNUM_CURRENCY_ISO: // do not support plural formatting here
1342 case UNUM_CURRENCY_PLURAL:
1343 case UNUM_CURRENCY_ACCOUNTING:
1344 case UNUM_CASH_CURRENCY:
1345 case UNUM_CURRENCY_STANDARD:
1346 {
1347 LocalPointer<Win32NumberFormat> f(new Win32NumberFormat(desiredLocale, curr, status), status);
1348 if (U_SUCCESS(status)) {
1349 return f.orphan();
1350 }
1351 }
1352 break;
1353 default:
1354 break;
1355 }
1356 }
1357 }
1358#endif
1359 // Use numbering system cache hashtable
1360 umtx_initOnce(gNSCacheInitOnce, &nscacheInit);
1361
1362 // Get cached numbering system
1363 LocalPointer<NumberingSystem> ownedNs;
1364 NumberingSystem *ns = NULL;
1365 if (NumberingSystem_cache != NULL) {
1366 // TODO: Bad hash key usage, see ticket #8504.
1367 int32_t hashKey = desiredLocale.hashCode();
1368
1369 static UMutex nscacheMutex;
1370 Mutex lock(&nscacheMutex);
1371 ns = (NumberingSystem *)uhash_iget(NumberingSystem_cache, hashKey);
1372 if (ns == NULL) {
1373 ns = NumberingSystem::createInstance(desiredLocale,status);
1374 uhash_iput(NumberingSystem_cache, hashKey, (void*)ns, &status);
1375 }
1376 } else {
1377 ownedNs.adoptInstead(NumberingSystem::createInstance(desiredLocale,status));
1378 ns = ownedNs.getAlias();
1379 }
1380
1381 // check results of getting a numbering system
1382 if (U_FAILURE(status)) {
1383 return NULL;
1384 }
1385
1386 if (mustBeDecimalFormat && ns->isAlgorithmic()) {
1387 status = U_UNSUPPORTED_ERROR;
1388 return NULL;
1389 }
1390
1391 LocalPointer<DecimalFormatSymbols> symbolsToAdopt;
1392 UnicodeString pattern;
1393 LocalUResourceBundlePointer ownedResource(ures_open(NULL, desiredLocale.getName(), &status));
1394 if (U_FAILURE(status)) {
1395 return NULL;
1396 }
1397 else {
1398 // Loads the decimal symbols of the desired locale.
1399 symbolsToAdopt.adoptInsteadAndCheckErrorCode(new DecimalFormatSymbols(desiredLocale, status), status);
1400 if (U_FAILURE(status)) {
1401 return NULL;
1402 }
1403
1404 // Load the pattern from data using the common library function
1405 const char16_t* patternPtr = number::impl::utils::getPatternForStyle(
1406 desiredLocale,
1407 ns->getName(),
1408 gFormatCldrStyles[style],
1409 status);
1410 pattern = UnicodeString(TRUE, patternPtr, -1);
1411 }
1412 if (U_FAILURE(status)) {
1413 return NULL;
1414 }
1415 if(style==UNUM_CURRENCY || style == UNUM_CURRENCY_ISO || style == UNUM_CURRENCY_ACCOUNTING
1416 || style == UNUM_CASH_CURRENCY || style == UNUM_CURRENCY_STANDARD){
1417 const UChar* currPattern = symbolsToAdopt->getCurrencyPattern();
1418 if(currPattern!=NULL){
1419 pattern.setTo(currPattern, u_strlen(currPattern));
1420 }
1421 }
1422
1423 LocalPointer<NumberFormat> f;
1424 if (ns->isAlgorithmic()) {
1425 UnicodeString nsDesc;
1426 UnicodeString nsRuleSetGroup;
1427 UnicodeString nsRuleSetName;
1428 Locale nsLoc;
1429 URBNFRuleSetTag desiredRulesType = URBNF_NUMBERING_SYSTEM;
1430
1431 nsDesc.setTo(ns->getDescription());
1432 int32_t firstSlash = nsDesc.indexOf(gSlash);
1433 int32_t lastSlash = nsDesc.lastIndexOf(gSlash);
1434 if ( lastSlash > firstSlash ) {
1435 CharString nsLocID;
1436
1437 nsLocID.appendInvariantChars(nsDesc.tempSubString(0, firstSlash), status);
1438 nsRuleSetGroup.setTo(nsDesc,firstSlash+1,lastSlash-firstSlash-1);
1439 nsRuleSetName.setTo(nsDesc,lastSlash+1);
1440
1441 nsLoc = Locale::createFromName(nsLocID.data());
1442
1443 UnicodeString SpelloutRules = UNICODE_STRING_SIMPLE("SpelloutRules");
1444 if ( nsRuleSetGroup.compare(SpelloutRules) == 0 ) {
1445 desiredRulesType = URBNF_SPELLOUT;
1446 }
1447 } else {
1448 nsLoc = desiredLocale;
1449 nsRuleSetName.setTo(nsDesc);
1450 }
1451
1452 RuleBasedNumberFormat *r = new RuleBasedNumberFormat(desiredRulesType,nsLoc,status);
1453 if (r == NULL) {
1454 status = U_MEMORY_ALLOCATION_ERROR;
1455 return NULL;
1456 }
1457 r->setDefaultRuleSet(nsRuleSetName,status);
1458 f.adoptInstead(r);
1459 } else {
1460 // replace single currency sign in the pattern with double currency sign
1461 // if the style is UNUM_CURRENCY_ISO
1462 if (style == UNUM_CURRENCY_ISO) {
1463 pattern.findAndReplace(UnicodeString(TRUE, gSingleCurrencySign, 1),
1464 UnicodeString(TRUE, gDoubleCurrencySign, 2));
1465 }
1466
1467 // "new DecimalFormat()" does not adopt the symbols argument if its memory allocation fails.
1468 // So we can't use adoptInsteadAndCheckErrorCode as we need to know if the 'new' failed.
1469 DecimalFormatSymbols *syms = symbolsToAdopt.getAlias();
1470 LocalPointer<DecimalFormat> df(new DecimalFormat(pattern, syms, style, status));
1471
1472 if (df.isValid()) {
1473 // if the DecimalFormat object was successfully new'ed, then it will own symbolsToAdopt, even if the status is a failure.
1474 symbolsToAdopt.orphan();
1475 }
1476 else {
1477 status = U_MEMORY_ALLOCATION_ERROR;
1478 }
1479
1480 if (U_FAILURE(status)) {
1481 return nullptr;
1482 }
1483
1484 // if it is cash currency style, setCurrencyUsage with usage
1485 if (style == UNUM_CASH_CURRENCY){
1486 df->setCurrencyUsage(UCURR_USAGE_CASH, &status);
1487 }
1488
1489 if (U_FAILURE(status)) {
1490 return nullptr;
1491 }
1492
1493 f.adoptInstead(df.orphan());
1494 }
1495
1496 f->setLocaleIDs(ures_getLocaleByType(ownedResource.getAlias(), ULOC_VALID_LOCALE, &status),
1497 ures_getLocaleByType(ownedResource.getAlias(), ULOC_ACTUAL_LOCALE, &status));
1498 if (U_FAILURE(status)) {
1499 return NULL;
1500 }
1501 return f.orphan();
1502}
1503
1504/**
1505 * Get the rounding mode.
1506 * @return A rounding mode
1507 */
1508NumberFormat::ERoundingMode NumberFormat::getRoundingMode() const {
1509 // Default value. ICU4J throws an exception and we can't change this API.
1510 return NumberFormat::ERoundingMode::kRoundUnnecessary;
1511}
1512
1513/**
1514 * Set the rounding mode. This has no effect unless the rounding
1515 * increment is greater than zero.
1516 * @param roundingMode A rounding mode
1517 */
1518void NumberFormat::setRoundingMode(NumberFormat::ERoundingMode /*roundingMode*/) {
1519 // No-op ICU4J throws an exception, and we can't change this API.
1520}
1521
1522U_NAMESPACE_END
1523
1524#endif /* #if !UCONFIG_NO_FORMATTING */
1525
1526//eof
1527