numfmt.cpp (49294B)
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 accommodate 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> 64 static 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. 77 static const char16_t gLastResortDecimalPat[] = { 78 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0 /* "#,##0.###" */ 79 }; 80 static const char16_t gLastResortCurrencyPat[] = { 81 0xA4, 0xA0, 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x30, 0x30, 0 /* "\u00A4\u00A0#,##0.00" */ 82 }; 83 static const char16_t gLastResortPercentPat[] = { 84 0x23, 0x2C, 0x23, 0x23, 0x30, 0x25, 0 /* "#,##0%" */ 85 }; 86 static const char16_t gLastResortScientificPat[] = { 87 0x23, 0x45, 0x30, 0 /* "#E0" */ 88 }; 89 static const char16_t gLastResortIsoCurrencyPat[] = { 90 0xA4, 0xA4, 0xA0, 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x30, 0x30, 0 /* "\u00A4\u00A4\u00A0#,##0.00" */ 91 }; 92 static const char16_t gLastResortPluralCurrencyPat[] = { 93 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x23, 0x23, 0x23, 0x20, 0xA4, 0xA4, 0xA4, 0 /* "#,##0.### \u00A4\u00A4\u00A4*/ 94 }; 95 static const char16_t gLastResortAccountingCurrencyPat[] = { 96 0xA4, 0xA0, 0x23, 0x2C, 0x23, 0x23, 0x30, 0x2E, 0x30, 0x30, 0 /* "\u00A4\u00A0#,##0.00" */ 97 }; 98 99 static const char16_t gSingleCurrencySign[] = {0xA4, 0}; 100 static const char16_t gDoubleCurrencySign[] = {0xA4, 0xA4, 0}; 101 102 static const char16_t 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 108 const int32_t icu::NumberFormat::gDefaultMaxIntegerDigits = 2000000000; 109 const int32_t icu::NumberFormat::gDefaultMinIntegerDigits = 127; 110 111 static const char16_t * const gLastResortNumberPatterns[UNUM_FORMAT_STYLE_COUNT] = { 112 nullptr, // UNUM_PATTERN_DECIMAL 113 gLastResortDecimalPat, // UNUM_DECIMAL 114 gLastResortCurrencyPat, // UNUM_CURRENCY 115 gLastResortPercentPat, // UNUM_PERCENT 116 gLastResortScientificPat, // UNUM_SCIENTIFIC 117 nullptr, // UNUM_SPELLOUT 118 nullptr, // UNUM_ORDINAL 119 nullptr, // UNUM_DURATION 120 gLastResortDecimalPat, // UNUM_NUMBERING_SYSTEM 121 nullptr, // UNUM_PATTERN_RULEBASED 122 gLastResortIsoCurrencyPat, // UNUM_CURRENCY_ISO 123 gLastResortPluralCurrencyPat, // UNUM_CURRENCY_PLURAL 124 gLastResortAccountingCurrencyPat, // UNUM_CURRENCY_ACCOUNTING 125 gLastResortCurrencyPat, // UNUM_CASH_CURRENCY 126 nullptr, // UNUM_DECIMAL_COMPACT_SHORT 127 nullptr, // UNUM_DECIMAL_COMPACT_LONG 128 gLastResortCurrencyPat, // UNUM_CURRENCY_STANDARD 129 }; 130 131 // Keys used for accessing resource bundles 132 133 static const icu::number::impl::CldrPatternStyle gFormatCldrStyles[UNUM_FORMAT_STYLE_COUNT] = { 134 /* nullptr */ 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 /* nullptr */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_SPELLOUT 140 /* nullptr */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_ORDINAL 141 /* nullptr */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_DURATION 142 /* nullptr */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_NUMBERING_SYSTEM 143 /* nullptr */ 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 /* nullptr */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT, // UNUM_DECIMAL_COMPACT_SHORT 153 /* nullptr */ 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 158 static UHashtable * NumberingSystem_cache = nullptr; 159 static icu::UInitOnce gNSCacheInitOnce {}; 160 161 #if !UCONFIG_NO_SERVICE 162 static icu::ICULocaleService* gService = nullptr; 163 static icu::UInitOnce gServiceInitOnce {}; 164 #endif 165 166 /** 167 * Release all static memory held by Number Format. 168 */ 169 U_CDECL_BEGIN 170 static void U_CALLCONV 171 deleteNumberingSystem(void *obj) { 172 delete (icu::NumberingSystem *)obj; 173 } 174 175 static UBool U_CALLCONV numfmt_cleanup() { 176 #if !UCONFIG_NO_SERVICE 177 gServiceInitOnce.reset(); 178 if (gService) { 179 delete gService; 180 gService = nullptr; 181 } 182 #endif 183 gNSCacheInitOnce.reset(); 184 if (NumberingSystem_cache) { 185 // delete NumberingSystem_cache; 186 uhash_close(NumberingSystem_cache); 187 NumberingSystem_cache = nullptr; 188 } 189 return true; 190 } 191 U_CDECL_END 192 193 // ***************************************************************************** 194 // class NumberFormat 195 // ***************************************************************************** 196 197 U_NAMESPACE_BEGIN 198 199 UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(NumberFormat) 200 201 #if !UCONFIG_NO_SERVICE 202 // ------------------------------------- 203 // SimpleNumberFormatFactory implementation 204 NumberFormatFactory::~NumberFormatFactory() {} 205 SimpleNumberFormatFactory::SimpleNumberFormatFactory(const Locale& locale, UBool visible) 206 : _visible(visible) 207 { 208 LocaleUtility::initNameFromLocale(locale, _id); 209 } 210 211 SimpleNumberFormatFactory::~SimpleNumberFormatFactory() {} 212 213 UBool SimpleNumberFormatFactory::visible() const { 214 return _visible; 215 } 216 217 const UnicodeString * 218 SimpleNumberFormatFactory::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 nullptr; 226 } 227 #endif /* #if !UCONFIG_NO_SERVICE */ 228 229 // ------------------------------------- 230 // default constructor 231 NumberFormat::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 246 NumberFormat::~NumberFormat() 247 { 248 } 249 250 SharedNumberFormat::~SharedNumberFormat() { 251 delete ptr; 252 } 253 254 // ------------------------------------- 255 // copy constructor 256 257 NumberFormat::NumberFormat(const NumberFormat &source) 258 : Format(source) 259 { 260 *this = source; 261 } 262 263 // ------------------------------------- 264 // assignment operator 265 266 NumberFormat& 267 NumberFormat::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 288 bool 289 NumberFormat::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 352 UnicodeString& 353 NumberFormat::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 368 UnicodeString& 369 NumberFormat::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 384 UnicodeString& 385 NumberFormat::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 398 UnicodeString& 399 NumberFormat::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 410 UnicodeString& 411 NumberFormat::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 422 UnicodeString& 423 NumberFormat::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 451 UnicodeString& 452 NumberFormat::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 */ 475 class ArgExtractor { 476 const Formattable* num; 477 char16_t 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() const; 485 const char16_t *iso() const; 486 UBool wasCurrency() const; 487 }; 488 489 inline const Formattable* 490 ArgExtractor::number() const { 491 return num; 492 } 493 494 inline UBool 495 ArgExtractor::wasCurrency() const { 496 return fWasCurrency; 497 } 498 499 inline const char16_t * 500 ArgExtractor::iso() const { 501 return save; 502 } 503 504 ArgExtractor::ArgExtractor(const NumberFormat& /*nf*/, const Formattable& obj, UErrorCode& /*status*/) 505 : num(&obj), fWasCurrency(false) { 506 507 const UObject* o = obj.getObject(); // most commonly o==nullptr 508 const CurrencyAmount* amt; 509 if (o != nullptr && (amt = dynamic_cast<const CurrencyAmount*>(o)) != nullptr) { 510 // getISOCurrency() returns a pointer to internal storage, so we 511 // copy it to retain it across the call to setCurrency(). 512 //const char16_t* 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 521 ArgExtractor::~ArgExtractor() { 522 } 523 524 UnicodeString& 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 541 UnicodeString& 542 NumberFormat::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 557 UnicodeString& 558 NumberFormat::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 char16_t *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() != nullptr) { 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 612 UnicodeString& 613 NumberFormat::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 char16_t *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() != nullptr) { 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 658 UnicodeString& 659 NumberFormat::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(static_cast<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 671 void 672 NumberFormat::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 682 UnicodeString& 683 NumberFormat::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 692 UnicodeString& 693 NumberFormat::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 702 UnicodeString& 703 NumberFormat::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 715 void 716 NumberFormat::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 729 CurrencyAmount* 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 char16_t 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 nullptr; 749 } 750 751 // ------------------------------------- 752 // Sets to only parse integers. 753 754 void 755 NumberFormat::setParseIntegerOnly(UBool value) 756 { 757 fParseIntegerOnly = value; 758 } 759 760 // ------------------------------------- 761 // Sets whether lenient parse is enabled. 762 763 void 764 NumberFormat::setLenient(UBool enable) 765 { 766 fLenient = enable; 767 } 768 769 // ------------------------------------- 770 // Create a number style NumberFormat instance with the default locale. 771 772 NumberFormat* U_EXPORT2 773 NumberFormat::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 781 NumberFormat* U_EXPORT2 782 NumberFormat::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 790 NumberFormat* U_EXPORT2 791 NumberFormat::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 799 NumberFormat* U_EXPORT2 800 NumberFormat::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 808 NumberFormat* U_EXPORT2 809 NumberFormat::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 817 NumberFormat* U_EXPORT2 818 NumberFormat::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 826 NumberFormat* U_EXPORT2 827 NumberFormat::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 835 NumberFormat* U_EXPORT2 836 NumberFormat::createScientificInstance(const Locale& inLocale, UErrorCode& status) 837 { 838 return createInstance(inLocale, UNUM_SCIENTIFIC, status); 839 } 840 841 // ------------------------------------- 842 843 const Locale* U_EXPORT2 844 NumberFormat::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 859 class ICUNumberFormatFactory : public ICUResourceBundleFactory { 860 public: 861 virtual ~ICUNumberFormatFactory(); 862 protected: 863 virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /* service */, UErrorCode& status) const override { 864 return NumberFormat::makeInstance(loc, static_cast<UNumberFormatStyle>(kind), status); 865 } 866 }; 867 868 ICUNumberFormatFactory::~ICUNumberFormatFactory() {} 869 870 // ------------------------------------- 871 872 class NFFactory : public LocaleKeyFactory { 873 private: 874 NumberFormatFactory* _delegate; 875 Hashtable* _ids; 876 877 public: 878 NFFactory(NumberFormatFactory* delegate) 879 : LocaleKeyFactory(delegate->visible() ? VISIBLE : INVISIBLE) 880 , _delegate(delegate) 881 , _ids(nullptr) 882 { 883 } 884 885 virtual ~NFFactory(); 886 887 virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const override 888 { 889 if (handlesKey(key, status)) { 890 const LocaleKey* lkey = dynamic_cast<const LocaleKey*>(&key); 891 U_ASSERT(lkey != nullptr); 892 Locale loc; 893 lkey->canonicalLocale(loc); 894 int32_t kind = lkey->kind(); 895 896 UObject* result = _delegate->createFormat(loc, static_cast<UNumberFormatStyle>(kind)); 897 if (result == nullptr) { 898 result = service->getKey(const_cast<ICUServiceKey&>(key) /* cast away const */, nullptr, this, status); 899 } 900 return result; 901 } 902 return nullptr; 903 } 904 905 protected: 906 /** 907 * Return the set of ids that this factory supports (visible or 908 * otherwise). This can be called often and might need to be 909 * cached if it is expensive to create. 910 */ 911 virtual const Hashtable* getSupportedIDs(UErrorCode& status) const override 912 { 913 if (U_SUCCESS(status)) { 914 if (!_ids) { 915 int32_t count = 0; 916 const UnicodeString * const idlist = _delegate->getSupportedIDs(count, status); 917 const_cast<NFFactory*>(this)->_ids = new Hashtable(status); /* cast away const */ 918 if (_ids) { 919 for (int i = 0; i < count; ++i) { 920 _ids->put(idlist[i], (void*)this, status); 921 } 922 } 923 } 924 return _ids; 925 } 926 return nullptr; 927 } 928 }; 929 930 NFFactory::~NFFactory() 931 { 932 delete _delegate; 933 delete _ids; 934 } 935 936 class ICUNumberFormatService : public ICULocaleService { 937 public: 938 ICUNumberFormatService() 939 : ICULocaleService(UNICODE_STRING_SIMPLE("Number Format")) 940 { 941 UErrorCode status = U_ZERO_ERROR; 942 registerFactory(new ICUNumberFormatFactory(), status); 943 } 944 945 virtual ~ICUNumberFormatService(); 946 947 virtual UObject* cloneInstance(UObject* instance) const override { 948 return ((NumberFormat*)instance)->clone(); 949 } 950 951 virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /* actualID */, UErrorCode& status) const override { 952 const LocaleKey* lkey = dynamic_cast<const LocaleKey*>(&key); 953 U_ASSERT(lkey != nullptr); 954 int32_t kind = lkey->kind(); 955 Locale loc; 956 lkey->currentLocale(loc); 957 return NumberFormat::makeInstance(loc, static_cast<UNumberFormatStyle>(kind), status); 958 } 959 960 virtual UBool isDefault() const override { 961 return countFactories() == 1; 962 } 963 }; 964 965 ICUNumberFormatService::~ICUNumberFormatService() {} 966 967 // ------------------------------------- 968 969 static void U_CALLCONV initNumberFormatService() { 970 U_ASSERT(gService == nullptr); 971 ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup); 972 gService = new ICUNumberFormatService(); 973 } 974 975 static ICULocaleService* 976 getNumberFormatService() 977 { 978 umtx_initOnce(gServiceInitOnce, &initNumberFormatService); 979 return gService; 980 } 981 982 static UBool haveService() { 983 return !gServiceInitOnce.isReset() && (getNumberFormatService() != nullptr); 984 } 985 986 // ------------------------------------- 987 988 URegistryKey U_EXPORT2 989 NumberFormat::registerFactory(NumberFormatFactory* toAdopt, UErrorCode& status) 990 { 991 if (U_FAILURE(status)) { 992 delete toAdopt; 993 return nullptr; 994 } 995 ICULocaleService *service = getNumberFormatService(); 996 if (service) { 997 NFFactory *tempnnf = new NFFactory(toAdopt); 998 if (tempnnf != nullptr) { 999 return service->registerFactory(tempnnf, status); 1000 } 1001 } 1002 status = U_MEMORY_ALLOCATION_ERROR; 1003 return nullptr; 1004 } 1005 1006 // ------------------------------------- 1007 1008 UBool U_EXPORT2 1009 NumberFormat::unregister(URegistryKey key, UErrorCode& status) 1010 { 1011 if (U_FAILURE(status)) { 1012 return false; 1013 } 1014 if (haveService()) { 1015 return gService->unregister(key, status); 1016 } else { 1017 status = U_ILLEGAL_ARGUMENT_ERROR; 1018 return false; 1019 } 1020 } 1021 1022 // ------------------------------------- 1023 StringEnumeration* U_EXPORT2 1024 NumberFormat::getAvailableLocales() 1025 { 1026 ICULocaleService *service = getNumberFormatService(); 1027 if (service) { 1028 return service->getAvailableLocales(); 1029 } 1030 return nullptr; // no way to return error condition 1031 } 1032 #endif /* UCONFIG_NO_SERVICE */ 1033 // ------------------------------------- 1034 1035 enum { kKeyValueLenMax = 32 }; 1036 1037 NumberFormat* 1038 NumberFormat::internalCreateInstance(const Locale& loc, UNumberFormatStyle kind, UErrorCode& status) { 1039 if (kind == UNUM_CURRENCY) { 1040 char cfKeyValue[kKeyValueLenMax] = {0}; 1041 UErrorCode kvStatus = U_ZERO_ERROR; 1042 int32_t kLen = loc.getKeywordValue("cf", cfKeyValue, kKeyValueLenMax, kvStatus); 1043 if (U_SUCCESS(kvStatus) && kLen > 0 && uprv_strcmp(cfKeyValue,"account")==0) { 1044 kind = UNUM_CURRENCY_ACCOUNTING; 1045 } 1046 } 1047 #if !UCONFIG_NO_SERVICE 1048 if (haveService()) { 1049 return (NumberFormat*)gService->get(loc, kind, status); 1050 } 1051 #endif 1052 return makeInstance(loc, kind, status); 1053 } 1054 1055 NumberFormat* U_EXPORT2 1056 NumberFormat::createInstance(const Locale& loc, UNumberFormatStyle kind, UErrorCode& status) { 1057 if (kind != UNUM_DECIMAL) { 1058 return internalCreateInstance(loc, kind, status); 1059 } 1060 const SharedNumberFormat *shared = createSharedInstance(loc, kind, status); 1061 if (U_FAILURE(status)) { 1062 return nullptr; 1063 } 1064 NumberFormat *result = (*shared)->clone(); 1065 shared->removeRef(); 1066 if (result == nullptr) { 1067 status = U_MEMORY_ALLOCATION_ERROR; 1068 } 1069 return result; 1070 } 1071 1072 1073 // ------------------------------------- 1074 // Checks if the thousand/10 thousand grouping is used in the 1075 // NumberFormat instance. 1076 1077 UBool 1078 NumberFormat::isGroupingUsed() const 1079 { 1080 return fGroupingUsed; 1081 } 1082 1083 // ------------------------------------- 1084 // Sets to use the thousand/10 thousand grouping in the 1085 // NumberFormat instance. 1086 1087 void 1088 NumberFormat::setGroupingUsed(UBool newValue) 1089 { 1090 fGroupingUsed = newValue; 1091 } 1092 1093 // ------------------------------------- 1094 // Gets the maximum number of digits for the integral part for 1095 // this NumberFormat instance. 1096 1097 int32_t NumberFormat::getMaximumIntegerDigits() const 1098 { 1099 return fMaxIntegerDigits; 1100 } 1101 1102 // ------------------------------------- 1103 // Sets the maximum number of digits for the integral part for 1104 // this NumberFormat instance. 1105 1106 void 1107 NumberFormat::setMaximumIntegerDigits(int32_t newValue) 1108 { 1109 fMaxIntegerDigits = uprv_max(0, uprv_min(newValue, gDefaultMaxIntegerDigits)); 1110 if(fMinIntegerDigits > fMaxIntegerDigits) 1111 fMinIntegerDigits = fMaxIntegerDigits; 1112 } 1113 1114 // ------------------------------------- 1115 // Gets the minimum number of digits for the integral part for 1116 // this NumberFormat instance. 1117 1118 int32_t 1119 NumberFormat::getMinimumIntegerDigits() const 1120 { 1121 return fMinIntegerDigits; 1122 } 1123 1124 // ------------------------------------- 1125 // Sets the minimum number of digits for the integral part for 1126 // this NumberFormat instance. 1127 1128 void 1129 NumberFormat::setMinimumIntegerDigits(int32_t newValue) 1130 { 1131 fMinIntegerDigits = uprv_max(0, uprv_min(newValue, gDefaultMinIntegerDigits)); 1132 if(fMinIntegerDigits > fMaxIntegerDigits) 1133 fMaxIntegerDigits = fMinIntegerDigits; 1134 } 1135 1136 // ------------------------------------- 1137 // Gets the maximum number of digits for the fractional part for 1138 // this NumberFormat instance. 1139 1140 int32_t 1141 NumberFormat::getMaximumFractionDigits() const 1142 { 1143 return fMaxFractionDigits; 1144 } 1145 1146 // ------------------------------------- 1147 // Sets the maximum number of digits for the fractional part for 1148 // this NumberFormat instance. 1149 1150 void 1151 NumberFormat::setMaximumFractionDigits(int32_t newValue) 1152 { 1153 fMaxFractionDigits = uprv_max(0, uprv_min(newValue, gDefaultMaxIntegerDigits)); 1154 if(fMaxFractionDigits < fMinFractionDigits) 1155 fMinFractionDigits = fMaxFractionDigits; 1156 } 1157 1158 // ------------------------------------- 1159 // Gets the minimum number of digits for the fractional part for 1160 // this NumberFormat instance. 1161 1162 int32_t 1163 NumberFormat::getMinimumFractionDigits() const 1164 { 1165 return fMinFractionDigits; 1166 } 1167 1168 // ------------------------------------- 1169 // Sets the minimum number of digits for the fractional part for 1170 // this NumberFormat instance. 1171 1172 void 1173 NumberFormat::setMinimumFractionDigits(int32_t newValue) 1174 { 1175 fMinFractionDigits = uprv_max(0, uprv_min(newValue, gDefaultMinIntegerDigits)); 1176 if (fMaxFractionDigits < fMinFractionDigits) 1177 fMaxFractionDigits = fMinFractionDigits; 1178 } 1179 1180 // ------------------------------------- 1181 1182 void NumberFormat::setCurrency(const char16_t* theCurrency, UErrorCode& ec) { 1183 if (U_FAILURE(ec)) { 1184 return; 1185 } 1186 if (theCurrency) { 1187 u_strncpy(fCurrency, theCurrency, 3); 1188 fCurrency[3] = 0; 1189 } else { 1190 fCurrency[0] = 0; 1191 } 1192 } 1193 1194 const char16_t* NumberFormat::getCurrency() const { 1195 return fCurrency; 1196 } 1197 1198 void NumberFormat::getEffectiveCurrency(char16_t* result, UErrorCode& ec) const { 1199 const char16_t* c = getCurrency(); 1200 if (*c != 0) { 1201 u_strncpy(result, c, 3); 1202 result[3] = 0; 1203 } else { 1204 const char* loc = getLocaleID(ULOC_VALID_LOCALE, ec); 1205 if (loc == nullptr) { 1206 loc = uloc_getDefault(); 1207 } 1208 ucurr_forLocale(loc, result, 4, &ec); 1209 } 1210 } 1211 1212 //---------------------------------------------------------------------- 1213 1214 1215 void NumberFormat::setContext(UDisplayContext value, UErrorCode& status) 1216 { 1217 if (U_FAILURE(status)) 1218 return; 1219 if (static_cast<UDisplayContextType>(static_cast<uint32_t>(value) >> 8) == UDISPCTX_TYPE_CAPITALIZATION) { 1220 fCapitalizationContext = value; 1221 } else { 1222 status = U_ILLEGAL_ARGUMENT_ERROR; 1223 } 1224 } 1225 1226 1227 UDisplayContext NumberFormat::getContext(UDisplayContextType type, UErrorCode& status) const 1228 { 1229 if (U_FAILURE(status)) 1230 return static_cast<UDisplayContext>(0); 1231 if (type != UDISPCTX_TYPE_CAPITALIZATION) { 1232 status = U_ILLEGAL_ARGUMENT_ERROR; 1233 return static_cast<UDisplayContext>(0); 1234 } 1235 return fCapitalizationContext; 1236 } 1237 1238 1239 // ------------------------------------- 1240 // Creates the NumberFormat instance of the specified style (number, currency, 1241 // or percent) for the desired locale. 1242 1243 static void U_CALLCONV nscacheInit() { 1244 U_ASSERT(NumberingSystem_cache == nullptr); 1245 ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup); 1246 UErrorCode status = U_ZERO_ERROR; 1247 NumberingSystem_cache = uhash_open(uhash_hashLong, 1248 uhash_compareLong, 1249 nullptr, 1250 &status); 1251 if (U_FAILURE(status)) { 1252 // Number Format code will run with no cache if creation fails. 1253 NumberingSystem_cache = nullptr; 1254 return; 1255 } 1256 uhash_setValueDeleter(NumberingSystem_cache, deleteNumberingSystem); 1257 } 1258 1259 template<> U_I18N_API 1260 const SharedNumberFormat *LocaleCacheKey<SharedNumberFormat>::createObject( 1261 const void * /*unused*/, UErrorCode &status) const { 1262 const char *localeId = fLoc.getName(); 1263 NumberFormat *nf = NumberFormat::internalCreateInstance( 1264 localeId, UNUM_DECIMAL, status); 1265 if (U_FAILURE(status)) { 1266 return nullptr; 1267 } 1268 SharedNumberFormat *result = new SharedNumberFormat(nf); 1269 if (result == nullptr) { 1270 status = U_MEMORY_ALLOCATION_ERROR; 1271 delete nf; 1272 return nullptr; 1273 } 1274 result->addRef(); 1275 return result; 1276 } 1277 1278 const SharedNumberFormat* U_EXPORT2 1279 NumberFormat::createSharedInstance(const Locale& loc, UNumberFormatStyle kind, UErrorCode& status) { 1280 if (U_FAILURE(status)) { 1281 return nullptr; 1282 } 1283 if (kind != UNUM_DECIMAL) { 1284 status = U_UNSUPPORTED_ERROR; 1285 return nullptr; 1286 } 1287 const SharedNumberFormat *result = nullptr; 1288 UnifiedCache::getByLocale(loc, result, status); 1289 return result; 1290 } 1291 1292 UBool 1293 NumberFormat::isStyleSupported(UNumberFormatStyle style) { 1294 return gLastResortNumberPatterns[style] != nullptr; 1295 } 1296 1297 NumberFormat* 1298 NumberFormat::makeInstance(const Locale& desiredLocale, 1299 UNumberFormatStyle style, 1300 UErrorCode& status) { 1301 return makeInstance(desiredLocale, style, false, status); 1302 } 1303 1304 NumberFormat* 1305 NumberFormat::makeInstance(const Locale& desiredLocale, 1306 UNumberFormatStyle style, 1307 UBool mustBeDecimalFormat, 1308 UErrorCode& status) { 1309 if (U_FAILURE(status)) return nullptr; 1310 1311 if (style < 0 || style >= UNUM_FORMAT_STYLE_COUNT) { 1312 status = U_ILLEGAL_ARGUMENT_ERROR; 1313 return nullptr; 1314 } 1315 1316 // For the purposes of general number formatting, UNUM_NUMBERING_SYSTEM should behave the same 1317 // was as UNUM_DECIMAL. In both cases, you get either a DecimalFormat or a RuleBasedNumberFormat 1318 // depending on the locale's numbering system (either the default one for the locale or a specific 1319 // one specified by using the "@numbers=" or "-u-nu-" parameter in the locale ID. 1320 if (style == UNUM_NUMBERING_SYSTEM) { 1321 style = UNUM_DECIMAL; 1322 } 1323 1324 // Some styles are not supported. This is a result of merging 1325 // the @draft ICU 4.2 NumberFormat::EStyles into the long-existing UNumberFormatStyle. 1326 // Ticket #8503 is for reviewing/fixing/merging the two relevant implementations: 1327 // this one and unum_open(). 1328 // The UNUM_PATTERN_ styles are not supported here 1329 // because this method does not take a pattern string. 1330 if (!isStyleSupported(style)) { 1331 status = U_UNSUPPORTED_ERROR; 1332 return nullptr; 1333 } 1334 1335 #if U_PLATFORM_USES_ONLY_WIN32_API 1336 if (!mustBeDecimalFormat) { 1337 char buffer[8]; 1338 int32_t count = desiredLocale.getKeywordValue("compat", buffer, sizeof(buffer), status); 1339 1340 // if the locale has "@compat=host", create a host-specific NumberFormat 1341 if (U_SUCCESS(status) && count > 0 && uprv_strcmp(buffer, "host") == 0) { 1342 UBool curr = true; 1343 1344 switch (style) { 1345 case UNUM_DECIMAL: 1346 curr = false; 1347 // fall-through 1348 U_FALLTHROUGH; 1349 1350 case UNUM_CURRENCY: 1351 case UNUM_CURRENCY_ISO: // do not support plural formatting here 1352 case UNUM_CURRENCY_PLURAL: 1353 case UNUM_CURRENCY_ACCOUNTING: 1354 case UNUM_CASH_CURRENCY: 1355 case UNUM_CURRENCY_STANDARD: 1356 { 1357 LocalPointer<Win32NumberFormat> f(new Win32NumberFormat(desiredLocale, curr, status), status); 1358 if (U_SUCCESS(status)) { 1359 return f.orphan(); 1360 } 1361 } 1362 break; 1363 default: 1364 break; 1365 } 1366 } 1367 } 1368 #endif 1369 // Use numbering system cache hashtable 1370 umtx_initOnce(gNSCacheInitOnce, &nscacheInit); 1371 1372 // Get cached numbering system 1373 LocalPointer<NumberingSystem> ownedNs; 1374 NumberingSystem *ns = nullptr; 1375 if (NumberingSystem_cache != nullptr) { 1376 // TODO: Bad hash key usage, see ticket #8504. 1377 int32_t hashKey = desiredLocale.hashCode(); 1378 1379 static UMutex nscacheMutex; 1380 Mutex lock(&nscacheMutex); 1381 ns = static_cast<NumberingSystem*>(uhash_iget(NumberingSystem_cache, hashKey)); 1382 if (ns == nullptr) { 1383 ns = NumberingSystem::createInstance(desiredLocale,status); 1384 uhash_iput(NumberingSystem_cache, hashKey, (void*)ns, &status); 1385 } 1386 } else { 1387 ownedNs.adoptInstead(NumberingSystem::createInstance(desiredLocale,status)); 1388 ns = ownedNs.getAlias(); 1389 } 1390 1391 // check results of getting a numbering system 1392 if (U_FAILURE(status)) { 1393 return nullptr; 1394 } 1395 1396 if (mustBeDecimalFormat && ns->isAlgorithmic()) { 1397 status = U_UNSUPPORTED_ERROR; 1398 return nullptr; 1399 } 1400 1401 LocalPointer<DecimalFormatSymbols> symbolsToAdopt; 1402 UnicodeString pattern; 1403 LocalUResourceBundlePointer ownedResource(ures_open(nullptr, desiredLocale.getName(), &status)); 1404 if (U_FAILURE(status)) { 1405 return nullptr; 1406 } 1407 else { 1408 // Loads the decimal symbols of the desired locale. 1409 symbolsToAdopt.adoptInsteadAndCheckErrorCode(new DecimalFormatSymbols(desiredLocale, status), status); 1410 if (U_FAILURE(status)) { 1411 return nullptr; 1412 } 1413 1414 // Load the pattern from data using the common library function 1415 const char16_t* patternPtr = number::impl::utils::getPatternForStyle( 1416 desiredLocale, 1417 ns->getName(), 1418 gFormatCldrStyles[style], 1419 status); 1420 pattern = UnicodeString(true, patternPtr, -1); 1421 } 1422 if (U_FAILURE(status)) { 1423 return nullptr; 1424 } 1425 if(style==UNUM_CURRENCY || style == UNUM_CURRENCY_ISO || style == UNUM_CURRENCY_ACCOUNTING 1426 || style == UNUM_CASH_CURRENCY || style == UNUM_CURRENCY_STANDARD){ 1427 const char16_t* currPattern = symbolsToAdopt->getCurrencyPattern(); 1428 if(currPattern!=nullptr){ 1429 pattern.setTo(currPattern, u_strlen(currPattern)); 1430 } 1431 } 1432 1433 LocalPointer<NumberFormat> f; 1434 if (ns->isAlgorithmic()) { 1435 UnicodeString nsDesc; 1436 UnicodeString nsRuleSetGroup; 1437 UnicodeString nsRuleSetName; 1438 Locale nsLoc; 1439 URBNFRuleSetTag desiredRulesType = URBNF_NUMBERING_SYSTEM; 1440 1441 nsDesc.setTo(ns->getDescription()); 1442 int32_t firstSlash = nsDesc.indexOf(gSlash); 1443 int32_t lastSlash = nsDesc.lastIndexOf(gSlash); 1444 if ( lastSlash > firstSlash ) { 1445 CharString nsLocID; 1446 1447 nsLocID.appendInvariantChars(nsDesc.tempSubString(0, firstSlash), status); 1448 nsRuleSetGroup.setTo(nsDesc,firstSlash+1,lastSlash-firstSlash-1); 1449 nsRuleSetName.setTo(nsDesc,lastSlash+1); 1450 1451 nsLoc = Locale::createFromName(nsLocID.data()); 1452 1453 UnicodeString SpelloutRules = UNICODE_STRING_SIMPLE("SpelloutRules"); 1454 if ( nsRuleSetGroup.compare(SpelloutRules) == 0 ) { 1455 desiredRulesType = URBNF_SPELLOUT; 1456 } 1457 } else { 1458 nsLoc = desiredLocale; 1459 nsRuleSetName.setTo(nsDesc); 1460 } 1461 1462 RuleBasedNumberFormat *r = new RuleBasedNumberFormat(desiredRulesType,nsLoc,status); 1463 if (r == nullptr) { 1464 status = U_MEMORY_ALLOCATION_ERROR; 1465 return nullptr; 1466 } 1467 r->setDefaultRuleSet(nsRuleSetName,status); 1468 f.adoptInstead(r); 1469 } else { 1470 // replace single currency sign in the pattern with double currency sign 1471 // if the style is UNUM_CURRENCY_ISO 1472 if (style == UNUM_CURRENCY_ISO) { 1473 pattern.findAndReplace(UnicodeString(true, gSingleCurrencySign, 1), 1474 UnicodeString(true, gDoubleCurrencySign, 2)); 1475 } 1476 1477 // "new DecimalFormat()" does not adopt the symbols argument if its memory allocation fails. 1478 // So we can't use adoptInsteadAndCheckErrorCode as we need to know if the 'new' failed. 1479 DecimalFormatSymbols *syms = symbolsToAdopt.getAlias(); 1480 LocalPointer<DecimalFormat> df(new DecimalFormat(pattern, syms, style, status)); 1481 1482 if (df.isValid()) { 1483 // if the DecimalFormat object was successfully new'ed, then it will own symbolsToAdopt, even if the status is a failure. 1484 symbolsToAdopt.orphan(); 1485 } 1486 else { 1487 status = U_MEMORY_ALLOCATION_ERROR; 1488 } 1489 1490 if (U_FAILURE(status)) { 1491 return nullptr; 1492 } 1493 1494 // if it is cash currency style, setCurrencyUsage with usage 1495 if (style == UNUM_CASH_CURRENCY){ 1496 df->setCurrencyUsage(UCURR_USAGE_CASH, &status); 1497 } 1498 1499 if (U_FAILURE(status)) { 1500 return nullptr; 1501 } 1502 1503 f.adoptInstead(df.orphan()); 1504 } 1505 1506 f->setLocaleIDs(ures_getLocaleByType(ownedResource.getAlias(), ULOC_VALID_LOCALE, &status), 1507 ures_getLocaleByType(ownedResource.getAlias(), ULOC_ACTUAL_LOCALE, &status)); 1508 if (U_FAILURE(status)) { 1509 return nullptr; 1510 } 1511 return f.orphan(); 1512 } 1513 1514 /** 1515 * Get the rounding mode. 1516 * @return A rounding mode 1517 */ 1518 NumberFormat::ERoundingMode NumberFormat::getRoundingMode() const { 1519 // Default value. ICU4J throws an exception and we can't change this API. 1520 return NumberFormat::ERoundingMode::kRoundUnnecessary; 1521 } 1522 1523 /** 1524 * Set the rounding mode. This has no effect unless the rounding 1525 * increment is greater than zero. 1526 * @param roundingMode A rounding mode 1527 */ 1528 void NumberFormat::setRoundingMode(NumberFormat::ERoundingMode /*roundingMode*/) { 1529 // No-op ICU4J throws an exception, and we can't change this API. 1530 } 1531 1532 U_NAMESPACE_END 1533 1534 #endif /* #if !UCONFIG_NO_FORMATTING */ 1535 1536 //eof