icuSources/i18n/numfmt.cpp

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