icuSources/i18n/decimfmtimpl.cpp

   1 /*
   2  * Copyright (C) 2015, International Business Machines
   3  * Corporation and others.  All Rights Reserved.
   4  *
   5  * file name: decimfmtimpl.cpp
   6  */
   7
   8 #include "unicode/utypes.h"
   9
  10 #if !UCONFIG_NO_FORMATTING
  11
  12 #include <math.h>
  13 #include "unicode/numfmt.h"
  14 #include "unicode/plurrule.h"
  15 #include "unicode/ustring.h"
  16 #include "decimalformatpattern.h"
  17 #include "decimalformatpatternimpl.h"
  18 #include "decimfmtimpl.h"
  19 #include "fphdlimp.h"
  20 #include "plurrule_impl.h"
  21 #include "valueformatter.h"
  22 #include "visibledigits.h"
  23
  24 U_NAMESPACE_BEGIN
  25
  26 static const int32_t kMaxScientificIntegerDigits = 8;
  27
  28 static const int32_t kFormattingPosPrefix = (1 << 0);
  29 static const int32_t kFormattingNegPrefix = (1 << 1);
  30 static const int32_t kFormattingPosSuffix = (1 << 2);
  31 static const int32_t kFormattingNegSuffix = (1 << 3);
  32 static const int32_t kFormattingSymbols = (1 << 4);
  33 static const int32_t kFormattingCurrency = (1 << 5);
  34 static const int32_t kFormattingUsesCurrency = (1 << 6);
  35 static const int32_t kFormattingPluralRules = (1 << 7);
  36 static const int32_t kFormattingAffixParser = (1 << 8);
  37 static const int32_t kFormattingCurrencyAffixInfo = (1 << 9);
  38 static const int32_t kFormattingAll = (1 << 10) - 1;
  39 static const int32_t kFormattingAffixes =
  40         kFormattingPosPrefix | kFormattingPosSuffix |
  41         kFormattingNegPrefix | kFormattingNegSuffix;
  42 static const int32_t kFormattingAffixParserWithCurrency =
  43         kFormattingAffixParser | kFormattingCurrencyAffixInfo;
  44
  45 DecimalFormatImpl::DecimalFormatImpl(
  46         NumberFormat *super,
  47         const Locale &locale,
  48         const UnicodeString &pattern,
  49         UErrorCode &status)
  50         : fSuper(super),
  51           fScale(0),
  52           fRoundingMode(DecimalFormat::kRoundHalfEven),
  53           fSymbols(NULL),
  54           fCurrencyUsage(UCURR_USAGE_STANDARD),
  55           fRules(NULL),
  56           fMonetary(FALSE) {
  57     if (U_FAILURE(status)) {
  58         return;
  59     }
  60     fSymbols = new DecimalFormatSymbols(
  61             locale, status);
  62     if (fSymbols == NULL) {
  63         status = U_MEMORY_ALLOCATION_ERROR;
  64         return;
  65     }
  66     UParseError parseError;
  67     applyPattern(pattern, FALSE, parseError, status);
  68     updateAll(status);
  69 }
  70
  71 DecimalFormatImpl::DecimalFormatImpl(
  72         NumberFormat *super,
  73         const UnicodeString &pattern,
  74         DecimalFormatSymbols *symbolsToAdopt,
  75         UParseError &parseError,
  76         UErrorCode &status)
  77         : fSuper(super),
  78           fScale(0),
  79           fRoundingMode(DecimalFormat::kRoundHalfEven),
  80           fSymbols(symbolsToAdopt),
  81           fCurrencyUsage(UCURR_USAGE_STANDARD),
  82           fRules(NULL),
  83           fMonetary(FALSE) {
  84     applyPattern(pattern, FALSE, parseError, status);
  85     updateAll(status);
  86 }
  87
  88 DecimalFormatImpl::DecimalFormatImpl(
  89     NumberFormat *super, const DecimalFormatImpl &other, UErrorCode &status) :
  90           fSuper(super),
  91           fMultiplier(other.fMultiplier),
  92           fScale(other.fScale),
  93           fRoundingMode(other.fRoundingMode),
  94           fMinSigDigits(other.fMinSigDigits),
  95           fMaxSigDigits(other.fMaxSigDigits),
  96           fUseScientific(other.fUseScientific),
  97           fUseSigDigits(other.fUseSigDigits),
  98           fGrouping(other.fGrouping),
  99           fPositivePrefixPattern(other.fPositivePrefixPattern),
 100           fNegativePrefixPattern(other.fNegativePrefixPattern),
 101           fPositiveSuffixPattern(other.fPositiveSuffixPattern),
 102           fNegativeSuffixPattern(other.fNegativeSuffixPattern),
 103           fSymbols(other.fSymbols),
 104           fCurrencyUsage(other.fCurrencyUsage),
 105           fRules(NULL),
 106           fMonetary(other.fMonetary),
 107           fAffixParser(other.fAffixParser),
 108           fCurrencyAffixInfo(other.fCurrencyAffixInfo),
 109           fEffPrecision(other.fEffPrecision),
 110           fEffGrouping(other.fEffGrouping),
 111           fOptions(other.fOptions),
 112           fFormatter(other.fFormatter),
 113           fAffixes(other.fAffixes) {
 114     fSymbols = new DecimalFormatSymbols(*fSymbols);
 115     if (fSymbols == NULL && U_SUCCESS(status)) {
 116         status = U_MEMORY_ALLOCATION_ERROR;
 117     }
 118     if (other.fRules != NULL) {
 119         fRules = new PluralRules(*other.fRules);
 120         if (fRules == NULL && U_SUCCESS(status)) {
 121             status = U_MEMORY_ALLOCATION_ERROR;
 122         }
 123     }
 124 }
 125
 126
 127 DecimalFormatImpl &
 128 DecimalFormatImpl::assign(const DecimalFormatImpl &other, UErrorCode &status) {
 129     if (U_FAILURE(status) || this == &other) {
 130         return (*this);
 131     }
 132     UObject::operator=(other);
 133     fMultiplier = other.fMultiplier;
 134     fScale = other.fScale;
 135     fRoundingMode = other.fRoundingMode;
 136     fMinSigDigits = other.fMinSigDigits;
 137     fMaxSigDigits = other.fMaxSigDigits;
 138     fUseScientific = other.fUseScientific;
 139     fUseSigDigits = other.fUseSigDigits;
 140     fGrouping = other.fGrouping;
 141     fPositivePrefixPattern = other.fPositivePrefixPattern;
 142     fNegativePrefixPattern = other.fNegativePrefixPattern;
 143     fPositiveSuffixPattern = other.fPositiveSuffixPattern;
 144     fNegativeSuffixPattern = other.fNegativeSuffixPattern;
 145     fCurrencyUsage = other.fCurrencyUsage;
 146     fMonetary = other.fMonetary;
 147     fAffixParser = other.fAffixParser;
 148     fCurrencyAffixInfo = other.fCurrencyAffixInfo;
 149     fEffPrecision = other.fEffPrecision;
 150     fEffGrouping = other.fEffGrouping;
 151     fOptions = other.fOptions;
 152     fFormatter = other.fFormatter;
 153     fAffixes = other.fAffixes;
 154     *fSymbols = *other.fSymbols;
 155     if (fRules != NULL && other.fRules != NULL) {
 156         *fRules = *other.fRules;
 157     } else {
 158         delete fRules;
 159         fRules = other.fRules;
 160         if (fRules != NULL) {
 161             fRules = new PluralRules(*fRules);
 162             if (fRules == NULL) {
 163                 status = U_MEMORY_ALLOCATION_ERROR;
 164                 return *this;
 165             }
 166         }
 167     }
 168     return *this;
 169 }
 170
 171 UBool
 172 DecimalFormatImpl::operator==(const DecimalFormatImpl &other) const {
 173     if (this == &other) {
 174         return TRUE;
 175     }
 176     return (fMultiplier == other.fMultiplier)
 177             && (fScale == other.fScale)
 178             && (fRoundingMode == other.fRoundingMode)
 179             && (fMinSigDigits == other.fMinSigDigits)
 180             && (fMaxSigDigits == other.fMaxSigDigits)
 181             && (fUseScientific == other.fUseScientific)
 182             && (fUseSigDigits == other.fUseSigDigits)
 183             && fGrouping.equals(other.fGrouping)
 184             && fPositivePrefixPattern.equals(other.fPositivePrefixPattern)
 185             && fNegativePrefixPattern.equals(other.fNegativePrefixPattern)
 186             && fPositiveSuffixPattern.equals(other.fPositiveSuffixPattern)
 187             && fNegativeSuffixPattern.equals(other.fNegativeSuffixPattern)
 188             && fCurrencyUsage == other.fCurrencyUsage
 189             && fAffixParser.equals(other.fAffixParser)
 190             && fCurrencyAffixInfo.equals(other.fCurrencyAffixInfo)
 191             && fEffPrecision.equals(other.fEffPrecision)
 192             && fEffGrouping.equals(other.fEffGrouping)
 193             && fOptions.equals(other.fOptions)
 194             && fFormatter.equals(other.fFormatter)
 195             && fAffixes.equals(other.fAffixes)
 196             && (*fSymbols == *other.fSymbols)
 197             && ((fRules == other.fRules) || (
 198                     (fRules != NULL) && (other.fRules != NULL)
 199                     && (*fRules == *other.fRules)))
 200             && (fMonetary == other.fMonetary);
 201 }
 202
 203 DecimalFormatImpl::~DecimalFormatImpl() {
 204     delete fSymbols;
 205     delete fRules;
 206 }
 207
 208 ValueFormatter &
 209 DecimalFormatImpl::prepareValueFormatter(ValueFormatter &vf) const {
 210     if (fUseScientific) {
 211         vf.prepareScientificFormatting(
 212                 fFormatter, fEffPrecision, fOptions);
 213         return vf;
 214     }
 215     vf.prepareFixedDecimalFormatting(
 216             fFormatter, fEffGrouping, fEffPrecision.fMantissa, fOptions.fMantissa);
 217     return vf;
 218 }
 219
 220 int32_t
 221 DecimalFormatImpl::getPatternScale() const {
 222     UBool usesPercent = fPositivePrefixPattern.usesPercent() ||
 223             fPositiveSuffixPattern.usesPercent() ||
 224             fNegativePrefixPattern.usesPercent() ||
 225             fNegativeSuffixPattern.usesPercent();
 226     if (usesPercent) {
 227         return 2;
 228     }
 229     UBool usesPermill = fPositivePrefixPattern.usesPermill() ||
 230             fPositiveSuffixPattern.usesPermill() ||
 231             fNegativePrefixPattern.usesPermill() ||
 232             fNegativeSuffixPattern.usesPermill();
 233     if (usesPermill) {
 234         return 3;
 235     }
 236     return 0;
 237 }
 238
 239 void
 240 DecimalFormatImpl::setMultiplierScale(int32_t scale) {
 241     if (scale == 0) {
 242         // Needed to preserve equality. fMultiplier == 0 means
 243         // multiplier is 1.
 244         fMultiplier.set(0);
 245     } else {
 246         fMultiplier.set(1);
 247         fMultiplier.shiftDecimalRight(scale);
 248     }
 249 }
 250
 251 UnicodeString &
 252 DecimalFormatImpl::format(
 253         int32_t number,
 254         UnicodeString &appendTo,
 255         FieldPosition &pos,
 256         UErrorCode &status) const {
 257     FieldPositionOnlyHandler handler(pos);
 258     return formatInt32(number, appendTo, handler, status);
 259 }
 260
 261 UnicodeString &
 262 DecimalFormatImpl::format(
 263         int32_t number,
 264         UnicodeString &appendTo,
 265         FieldPositionIterator *posIter,
 266         UErrorCode &status) const {
 267     FieldPositionIteratorHandler handler(posIter, status);
 268     return formatInt32(number, appendTo, handler, status);
 269 }
 270
 271 template<class T>
 272 UBool DecimalFormatImpl::maybeFormatWithDigitList(
 273         T number,
 274         UnicodeString &appendTo,
 275         FieldPositionHandler &handler,
 276         UErrorCode &status) const {
 277     if (!fMultiplier.isZero()) {
 278         DigitList digits;
 279         digits.set(number);
 280         digits.mult(fMultiplier, status);
 281         digits.shiftDecimalRight(fScale);
 282         formatAdjustedDigitList(digits, appendTo, handler, status);
 283         return TRUE;
 284     }
 285     if (fScale != 0) {
 286         DigitList digits;
 287         digits.set(number);
 288         digits.shiftDecimalRight(fScale);
 289         formatAdjustedDigitList(digits, appendTo, handler, status);
 290         return TRUE;
 291     }
 292     return FALSE;
 293 }
 294
 295 template<class T>
 296 UBool DecimalFormatImpl::maybeInitVisibleDigitsFromDigitList(
 297         T number,
 298         VisibleDigitsWithExponent &visibleDigits,
 299         UErrorCode &status) const {
 300     if (!fMultiplier.isZero()) {
 301         DigitList digits;
 302         digits.set(number);
 303         digits.mult(fMultiplier, status);
 304         digits.shiftDecimalRight(fScale);
 305         initVisibleDigitsFromAdjusted(digits, visibleDigits, status);
 306         return TRUE;
 307     }
 308     if (fScale != 0) {
 309         DigitList digits;
 310         digits.set(number);
 311         digits.shiftDecimalRight(fScale);
 312         initVisibleDigitsFromAdjusted(digits, visibleDigits, status);
 313         return TRUE;
 314     }
 315     return FALSE;
 316 }
 317
 318 UnicodeString &
 319 DecimalFormatImpl::formatInt32(
 320         int32_t number,
 321         UnicodeString &appendTo,
 322         FieldPositionHandler &handler,
 323         UErrorCode &status) const {
 324     if (maybeFormatWithDigitList(number, appendTo, handler, status)) {
 325         return appendTo;
 326     }
 327     ValueFormatter vf;
 328     return fAffixes.formatInt32(
 329             number,
 330             prepareValueFormatter(vf),
 331             handler,
 332             fRules,
 333             appendTo,
 334             status);
 335 }
 336
 337 UnicodeString &
 338 DecimalFormatImpl::formatInt64(
 339         int64_t number,
 340         UnicodeString &appendTo,
 341         FieldPositionHandler &handler,
 342         UErrorCode &status) const {
 343     if (number >= INT32_MIN && number <= INT32_MAX) {
 344         return formatInt32((int32_t) number, appendTo, handler, status);
 345     }
 346     VisibleDigitsWithExponent digits;
 347     initVisibleDigitsWithExponent(number, digits, status);
 348     return formatVisibleDigitsWithExponent(
 349             digits, appendTo, handler, status);
 350 }
 351
 352 UnicodeString &
 353 DecimalFormatImpl::formatDouble(
 354         double number,
 355         UnicodeString &appendTo,
 356         FieldPositionHandler &handler,
 357         UErrorCode &status) const {
 358     VisibleDigitsWithExponent digits;
 359     initVisibleDigitsWithExponent(number, digits, status);
 360     return formatVisibleDigitsWithExponent(
 361             digits, appendTo, handler, status);
 362 }
 363
 364 UnicodeString &
 365 DecimalFormatImpl::format(
 366         double number,
 367         UnicodeString &appendTo,
 368         FieldPosition &pos,
 369         UErrorCode &status) const {
 370     FieldPositionOnlyHandler handler(pos);
 371     return formatDouble(number, appendTo, handler, status);
 372 }
 373
 374 UnicodeString &
 375 DecimalFormatImpl::format(
 376         const DigitList &number,
 377         UnicodeString &appendTo,
 378         FieldPosition &pos,
 379         UErrorCode &status) const {
 380     DigitList dl(number);
 381     FieldPositionOnlyHandler handler(pos);
 382     return formatDigitList(dl, appendTo, handler, status);
 383 }
 384
 385 UnicodeString &
 386 DecimalFormatImpl::format(
 387         int64_t number,
 388         UnicodeString &appendTo,
 389         FieldPosition &pos,
 390         UErrorCode &status) const {
 391     FieldPositionOnlyHandler handler(pos);
 392     return formatInt64(number, appendTo, handler, status);
 393 }
 394
 395 UnicodeString &
 396 DecimalFormatImpl::format(
 397         int64_t number,
 398         UnicodeString &appendTo,
 399         FieldPositionIterator *posIter,
 400         UErrorCode &status) const {
 401     FieldPositionIteratorHandler handler(posIter, status);
 402     return formatInt64(number, appendTo, handler, status);
 403 }
 404
 405 UnicodeString &
 406 DecimalFormatImpl::format(
 407         double number,
 408         UnicodeString &appendTo,
 409         FieldPositionIterator *posIter,
 410         UErrorCode &status) const {
 411     FieldPositionIteratorHandler handler(posIter, status);
 412     return formatDouble(number, appendTo, handler, status);
 413 }
 414
 415 UnicodeString &
 416 DecimalFormatImpl::format(
 417         const DigitList &number,
 418         UnicodeString &appendTo,
 419         FieldPositionIterator *posIter,
 420         UErrorCode &status) const {
 421     DigitList dl(number);
 422     FieldPositionIteratorHandler handler(posIter, status);
 423     return formatDigitList(dl, appendTo, handler, status);
 424 }
 425
 426 UnicodeString &
 427 DecimalFormatImpl::format(
 428         const StringPiece &number,
 429         UnicodeString &appendTo,
 430         FieldPositionIterator *posIter,
 431         UErrorCode &status) const {
 432     DigitList dl;
 433     dl.set(number, status);
 434     FieldPositionIteratorHandler handler(posIter, status);
 435     return formatDigitList(dl, appendTo, handler, status);
 436 }
 437
 438 UnicodeString &
 439 DecimalFormatImpl::format(
 440         const VisibleDigitsWithExponent &digits,
 441         UnicodeString &appendTo,
 442         FieldPosition &pos,
 443         UErrorCode &status) const {
 444     FieldPositionOnlyHandler handler(pos);
 445     return formatVisibleDigitsWithExponent(
 446             digits, appendTo, handler, status);
 447 }
 448
 449 UnicodeString &
 450 DecimalFormatImpl::format(
 451         const VisibleDigitsWithExponent &digits,
 452         UnicodeString &appendTo,
 453         FieldPositionIterator *posIter,
 454         UErrorCode &status) const {
 455     FieldPositionIteratorHandler handler(posIter, status);
 456     return formatVisibleDigitsWithExponent(
 457             digits, appendTo, handler, status);
 458 }
 459
 460 DigitList &
 461 DecimalFormatImpl::adjustDigitList(
 462         DigitList &number, UErrorCode &status) const {
 463     number.setRoundingMode(fRoundingMode);
 464     if (!fMultiplier.isZero()) {
 465         number.mult(fMultiplier, status);
 466     }
 467     if (fScale != 0) {
 468         number.shiftDecimalRight(fScale);
 469     }
 470     number.reduce();
 471     return number;
 472 }
 473
 474 UnicodeString &
 475 DecimalFormatImpl::formatDigitList(
 476         DigitList &number,
 477         UnicodeString &appendTo,
 478         FieldPositionHandler &handler,
 479         UErrorCode &status) const {
 480     VisibleDigitsWithExponent digits;
 481     initVisibleDigitsWithExponent(number, digits, status);
 482     return formatVisibleDigitsWithExponent(
 483             digits, appendTo, handler, status);
 484 }
 485
 486 UnicodeString &
 487 DecimalFormatImpl::formatAdjustedDigitList(
 488         DigitList &number,
 489         UnicodeString &appendTo,
 490         FieldPositionHandler &handler,
 491         UErrorCode &status) const {
 492     ValueFormatter vf;
 493     return fAffixes.format(
 494             number,
 495             prepareValueFormatter(vf),
 496             handler,
 497             fRules,
 498             appendTo,
 499             status);
 500 }
 501
 502 UnicodeString &
 503 DecimalFormatImpl::formatVisibleDigitsWithExponent(
 504         const VisibleDigitsWithExponent &digits,
 505         UnicodeString &appendTo,
 506         FieldPositionHandler &handler,
 507         UErrorCode &status) const {
 508     ValueFormatter vf;
 509     return fAffixes.format(
 510             digits,
 511             prepareValueFormatter(vf),
 512             handler,
 513             fRules,
 514             appendTo,
 515             status);
 516 }
 517
 518 static FixedDecimal &initFixedDecimal(
 519         const VisibleDigits &digits, FixedDecimal &result) {
 520     result.source = 0.0;
 521     result.isNegative = digits.isNegative();
 522     result.isNanOrInfinity = digits.isNaNOrInfinity();
 523     digits.getFixedDecimal(
 524             result.source, result.intValue, result.decimalDigits,
 525             result.decimalDigitsWithoutTrailingZeros,
 526             result.visibleDecimalDigitCount, result.hasIntegerValue);
 527     return result;
 528 }
 529
 530 FixedDecimal &
 531 DecimalFormatImpl::getFixedDecimal(double number, FixedDecimal &result, UErrorCode &status) const {
 532     if (U_FAILURE(status)) {
 533         return result;
 534     }
 535     VisibleDigits digits;
 536     fEffPrecision.fMantissa.initVisibleDigits(number, digits, status);
 537     return initFixedDecimal(digits, result);
 538 }
 539
 540 FixedDecimal &
 541 DecimalFormatImpl::getFixedDecimal(
 542         DigitList &number, FixedDecimal &result, UErrorCode &status) const {
 543     if (U_FAILURE(status)) {
 544         return result;
 545     }
 546     VisibleDigits digits;
 547     fEffPrecision.fMantissa.initVisibleDigits(number, digits, status);
 548     return initFixedDecimal(digits, result);
 549 }
 550
 551 VisibleDigitsWithExponent &
 552 DecimalFormatImpl::initVisibleDigitsWithExponent(
 553         int64_t number,
 554         VisibleDigitsWithExponent &digits,
 555         UErrorCode &status) const {
 556     if (maybeInitVisibleDigitsFromDigitList(
 557             number, digits, status)) {
 558         return digits;
 559     }
 560     if (fUseScientific) {
 561         fEffPrecision.initVisibleDigitsWithExponent(
 562                 number, digits, status);
 563     } else {
 564         fEffPrecision.fMantissa.initVisibleDigitsWithExponent(
 565                 number, digits, status);
 566     }
 567     return digits;
 568 }
 569
 570 VisibleDigitsWithExponent &
 571 DecimalFormatImpl::initVisibleDigitsWithExponent(
 572         double number,
 573         VisibleDigitsWithExponent &digits,
 574         UErrorCode &status) const {
 575     if (maybeInitVisibleDigitsFromDigitList(
 576             number, digits, status)) {
 577         return digits;
 578     }
 579     if (fUseScientific) {
 580         fEffPrecision.initVisibleDigitsWithExponent(
 581                 number, digits, status);
 582     } else {
 583         fEffPrecision.fMantissa.initVisibleDigitsWithExponent(
 584                 number, digits, status);
 585     }
 586     return digits;
 587 }
 588
 589 VisibleDigitsWithExponent &
 590 DecimalFormatImpl::initVisibleDigitsWithExponent(
 591         DigitList &number,
 592         VisibleDigitsWithExponent &digits,
 593         UErrorCode &status) const {
 594     adjustDigitList(number, status);
 595     return initVisibleDigitsFromAdjusted(number, digits, status);
 596 }
 597
 598 VisibleDigitsWithExponent &
 599 DecimalFormatImpl::initVisibleDigitsFromAdjusted(
 600         DigitList &number,
 601         VisibleDigitsWithExponent &digits,
 602         UErrorCode &status) const {
 603     if (fUseScientific) {
 604         fEffPrecision.initVisibleDigitsWithExponent(
 605                 number, digits, status);
 606     } else {
 607         fEffPrecision.fMantissa.initVisibleDigitsWithExponent(
 608                 number, digits, status);
 609     }
 610     return digits;
 611 }
 612
 613 DigitList &
 614 DecimalFormatImpl::round(
 615         DigitList &number, UErrorCode &status) const {
 616     if (number.isNaN() || number.isInfinite()) {
 617         return number;
 618     }
 619     adjustDigitList(number, status);
 620     ValueFormatter vf;
 621     prepareValueFormatter(vf);
 622     return vf.round(number, status);
 623 }
 624
 625 void
 626 DecimalFormatImpl::setMinimumSignificantDigits(int32_t newValue) {
 627     fMinSigDigits = newValue;
 628     fUseSigDigits = TRUE; // ticket 9936
 629     updatePrecision();
 630 }
 631
 632 void
 633 DecimalFormatImpl::setMaximumSignificantDigits(int32_t newValue) {
 634     fMaxSigDigits = newValue;
 635     fUseSigDigits = TRUE; // ticket 9936
 636     updatePrecision();
 637 }
 638
 639 void
 640 DecimalFormatImpl::setMinMaxSignificantDigits(int32_t min, int32_t max) {
 641     fMinSigDigits = min;
 642     fMaxSigDigits = max;
 643     fUseSigDigits = TRUE; // ticket 9936
 644     updatePrecision();
 645 }
 646
 647 void
 648 DecimalFormatImpl::setScientificNotation(UBool newValue) {
 649     fUseScientific = newValue;
 650     updatePrecision();
 651 }
 652
 653 void
 654 DecimalFormatImpl::setSignificantDigitsUsed(UBool newValue) {
 655     fUseSigDigits = newValue;
 656     updatePrecision();
 657 }
 658
 659 void
 660 DecimalFormatImpl::setGroupingSize(int32_t newValue) {
 661     fGrouping.fGrouping = newValue;
 662     updateGrouping();
 663 }
 664
 665 void
 666 DecimalFormatImpl::setSecondaryGroupingSize(int32_t newValue) {
 667     fGrouping.fGrouping2 = newValue;
 668     updateGrouping();
 669 }
 670
 671 void
 672 DecimalFormatImpl::setMinimumGroupingDigits(int32_t newValue) {
 673     fGrouping.fMinGrouping = newValue;
 674     updateGrouping();
 675 }
 676
 677 void
 678 DecimalFormatImpl::setCurrencyUsage(
 679         UCurrencyUsage currencyUsage, UErrorCode &status) {
 680     fCurrencyUsage = currencyUsage;
 681     updateFormatting(kFormattingCurrency, status);
 682 }
 683
 684 void
 685 DecimalFormatImpl::setRoundingIncrement(double d) {
 686     if (d > 0.0) {
 687         fEffPrecision.fMantissa.fRoundingIncrement.set(d);
 688     } else {
 689         fEffPrecision.fMantissa.fRoundingIncrement.set(0.0);
 690     }
 691 }
 692
 693 double
 694 DecimalFormatImpl::getRoundingIncrement() const {
 695     return fEffPrecision.fMantissa.fRoundingIncrement.getDouble();
 696 }
 697
 698 int32_t
 699 DecimalFormatImpl::getMultiplier() const {
 700     if (fMultiplier.isZero()) {
 701         return 1;
 702     }
 703     return (int32_t) fMultiplier.getDouble();
 704 }
 705
 706 void
 707 DecimalFormatImpl::setMultiplier(int32_t m) {
 708     if (m == 0 || m == 1) {
 709         fMultiplier.set(0);
 710     } else {
 711         fMultiplier.set(m);
 712     }
 713 }
 714
 715 void
 716 DecimalFormatImpl::setPositivePrefix(const UnicodeString &str) {
 717     fPositivePrefixPattern.remove();
 718     fPositivePrefixPattern.addLiteral(str.getBuffer(), 0, str.length());
 719     UErrorCode status = U_ZERO_ERROR;
 720     updateFormatting(kFormattingPosPrefix, status);
 721 }
 722
 723 void
 724 DecimalFormatImpl::setPositiveSuffix(const UnicodeString &str) {
 725     fPositiveSuffixPattern.remove();
 726     fPositiveSuffixPattern.addLiteral(str.getBuffer(), 0, str.length());
 727     UErrorCode status = U_ZERO_ERROR;
 728     updateFormatting(kFormattingPosSuffix, status);
 729 }
 730
 731 void
 732 DecimalFormatImpl::setNegativePrefix(const UnicodeString &str) {
 733     fNegativePrefixPattern.remove();
 734     fNegativePrefixPattern.addLiteral(str.getBuffer(), 0, str.length());
 735     UErrorCode status = U_ZERO_ERROR;
 736     updateFormatting(kFormattingNegPrefix, status);
 737 }
 738
 739 void
 740 DecimalFormatImpl::setNegativeSuffix(const UnicodeString &str) {
 741     fNegativeSuffixPattern.remove();
 742     fNegativeSuffixPattern.addLiteral(str.getBuffer(), 0, str.length());
 743     UErrorCode status = U_ZERO_ERROR;
 744     updateFormatting(kFormattingNegSuffix, status);
 745 }
 746
 747 UnicodeString &
 748 DecimalFormatImpl::getPositivePrefix(UnicodeString &result) const {
 749     result = fAffixes.fPositivePrefix.getOtherVariant().toString();
 750     return result;
 751 }
 752
 753 UnicodeString &
 754 DecimalFormatImpl::getPositiveSuffix(UnicodeString &result) const {
 755     result = fAffixes.fPositiveSuffix.getOtherVariant().toString();
 756     return result;
 757 }
 758
 759 UnicodeString &
 760 DecimalFormatImpl::getNegativePrefix(UnicodeString &result) const {
 761     result = fAffixes.fNegativePrefix.getOtherVariant().toString();
 762     return result;
 763 }
 764
 765 UnicodeString &
 766 DecimalFormatImpl::getNegativeSuffix(UnicodeString &result) const {
 767     result = fAffixes.fNegativeSuffix.getOtherVariant().toString();
 768     return result;
 769 }
 770
 771 void
 772 DecimalFormatImpl::adoptDecimalFormatSymbols(DecimalFormatSymbols *symbolsToAdopt) {
 773     if (symbolsToAdopt == NULL) {
 774         return;
 775     }
 776     delete fSymbols;
 777     fSymbols = symbolsToAdopt;
 778     UErrorCode status = U_ZERO_ERROR;
 779     updateFormatting(kFormattingSymbols, status);
 780 }
 781
 782 void
 783 DecimalFormatImpl::applyPatternFavorCurrencyPrecision(
 784         const UnicodeString &pattern, UErrorCode &status) {
 785     UParseError perror;
 786     applyPattern(pattern, FALSE, perror, status);
 787     updateForApplyPatternFavorCurrencyPrecision(status);
 788 }
 789
 790 void
 791 DecimalFormatImpl::applyPattern(
 792         const UnicodeString &pattern, UErrorCode &status) {
 793     UParseError perror;
 794     applyPattern(pattern, FALSE, perror, status);
 795     updateForApplyPattern(status);
 796 }
 797
 798 void
 799 DecimalFormatImpl::applyPattern(
 800         const UnicodeString &pattern,
 801         UParseError &perror, UErrorCode &status) {
 802     applyPattern(pattern, FALSE, perror, status);
 803     updateForApplyPattern(status);
 804 }
 805
 806 void
 807 DecimalFormatImpl::applyLocalizedPattern(
 808         const UnicodeString &pattern, UErrorCode &status) {
 809     UParseError perror;
 810     applyPattern(pattern, TRUE, perror, status);
 811     updateForApplyPattern(status);
 812 }
 813
 814 void
 815 DecimalFormatImpl::applyLocalizedPattern(
 816         const UnicodeString &pattern,
 817         UParseError &perror,  UErrorCode &status) {
 818     applyPattern(pattern, TRUE, perror, status);
 819     updateForApplyPattern(status);
 820 }
 821
 822 void
 823 DecimalFormatImpl::applyPattern(
 824         const UnicodeString &pattern,
 825         UBool localized, UParseError &perror, UErrorCode &status) {
 826     if (U_FAILURE(status)) {
 827         return;
 828     }
 829     DecimalFormatPatternParser patternParser;
 830     if (localized) {
 831         patternParser.useSymbols(*fSymbols);
 832     }
 833     DecimalFormatPattern out;
 834     patternParser.applyPatternWithoutExpandAffix(
 835             pattern, out, perror, status);
 836     if (U_FAILURE(status)) {
 837         return;
 838     }
 839     fUseScientific = out.fUseExponentialNotation;
 840     fUseSigDigits = out.fUseSignificantDigits;
 841     fSuper->NumberFormat::setMinimumIntegerDigits(out.fMinimumIntegerDigits);
 842     fSuper->NumberFormat::setMaximumIntegerDigits(out.fMaximumIntegerDigits);
 843     fSuper->NumberFormat::setMinimumFractionDigits(out.fMinimumFractionDigits);
 844     fSuper->NumberFormat::setMaximumFractionDigits(out.fMaximumFractionDigits);
 845     fMinSigDigits = out.fMinimumSignificantDigits;
 846     fMaxSigDigits = out.fMaximumSignificantDigits;
 847     fEffPrecision.fMinExponentDigits = out.fMinExponentDigits;
 848     fOptions.fExponent.fAlwaysShowSign = out.fExponentSignAlwaysShown;
 849     fSuper->NumberFormat::setGroupingUsed(out.fGroupingUsed);
 850     fGrouping.fGrouping = out.fGroupingSize;
 851     fGrouping.fGrouping2 = out.fGroupingSize2;
 852     fOptions.fMantissa.fAlwaysShowDecimal = out.fDecimalSeparatorAlwaysShown;
 853     if (out.fRoundingIncrementUsed) {
 854         fEffPrecision.fMantissa.fRoundingIncrement = out.fRoundingIncrement;
 855     } else {
 856         fEffPrecision.fMantissa.fRoundingIncrement.clear();
 857     }
 858     fAffixes.fPadChar = out.fPad;
 859     fNegativePrefixPattern = out.fNegPrefixAffix;
 860     fNegativeSuffixPattern = out.fNegSuffixAffix;
 861     fPositivePrefixPattern = out.fPosPrefixAffix;
 862     fPositiveSuffixPattern = out.fPosSuffixAffix;
 863
 864     // Work around. Pattern parsing code and DecimalFormat code don't agree
 865     // on the definition of field width, so we have to translate from
 866     // pattern field width to decimal format field width here.
 867     fAffixes.fWidth = out.fFormatWidth == 0 ? 0 :
 868             out.fFormatWidth + fPositivePrefixPattern.countChar32()
 869             + fPositiveSuffixPattern.countChar32();
 870     switch (out.fPadPosition) {
 871     case DecimalFormatPattern::kPadBeforePrefix:
 872         fAffixes.fPadPosition = DigitAffixesAndPadding::kPadBeforePrefix;
 873         break;
 874     case DecimalFormatPattern::kPadAfterPrefix:
 875         fAffixes.fPadPosition = DigitAffixesAndPadding::kPadAfterPrefix;
 876         break;
 877     case DecimalFormatPattern::kPadBeforeSuffix:
 878         fAffixes.fPadPosition = DigitAffixesAndPadding::kPadBeforeSuffix;
 879         break;
 880     case DecimalFormatPattern::kPadAfterSuffix:
 881         fAffixes.fPadPosition = DigitAffixesAndPadding::kPadAfterSuffix;
 882         break;
 883     default:
 884         break;
 885     }
 886 }
 887
 888 void
 889 DecimalFormatImpl::updatePrecision() {
 890     if (fUseScientific) {
 891         updatePrecisionForScientific();
 892     } else {
 893         updatePrecisionForFixed();
 894     }
 895 }
 896
 897 static void updatePrecisionForScientificMinMax(
 898         const DigitInterval &min,
 899         const DigitInterval &max,
 900         DigitInterval &resultMin,
 901         DigitInterval &resultMax,
 902         SignificantDigitInterval &resultSignificant) {
 903     resultMin.setIntDigitCount(0);
 904     resultMin.setFracDigitCount(0);
 905     resultSignificant.clear();
 906     resultMax.clear();
 907
 908     int32_t maxIntDigitCount = max.getIntDigitCount();
 909     int32_t minIntDigitCount = min.getIntDigitCount();
 910     int32_t maxFracDigitCount = max.getFracDigitCount();
 911     int32_t minFracDigitCount = min.getFracDigitCount();
 912
 913
 914     // Not in spec: maxIntDigitCount > 8 assume
 915     // maxIntDigitCount = minIntDigitCount. Current DecimalFormat API has
 916     // no provision for unsetting maxIntDigitCount which would be useful for
 917     // scientific notation. The best we can do is assume that if
 918     // maxIntDigitCount is the default of 2000000000 or is "big enough" then
 919     // user did not intend to explicitly set it. The 8 was derived emperically
 920     // by extensive testing of legacy code.
 921     if (maxIntDigitCount > 8) {
 922         maxIntDigitCount = minIntDigitCount;
 923     }
 924
 925     // Per the spec, exponent grouping happens if maxIntDigitCount is more
 926     // than 1 and more than minIntDigitCount.
 927     UBool bExponentGrouping = maxIntDigitCount > 1 && minIntDigitCount < maxIntDigitCount;
 928     if (bExponentGrouping) {
 929         resultMax.setIntDigitCount(maxIntDigitCount);
 930
 931         // For exponent grouping minIntDigits is always treated as 1 even
 932         // if it wasn't set to 1!
 933         resultMin.setIntDigitCount(1);
 934     } else {
 935         // Fixed digit count left of decimal. minIntDigitCount doesn't have
 936         // to equal maxIntDigitCount i.e minIntDigitCount == 0 while
 937         // maxIntDigitCount == 1.
 938         int32_t fixedIntDigitCount = maxIntDigitCount;
 939
 940         // If fixedIntDigitCount is 0 but
 941         // min or max fraction count is 0 too then use 1. This way we can get
 942         // unlimited precision for X.XXXEX
 943         if (fixedIntDigitCount == 0 && (minFracDigitCount == 0 || maxFracDigitCount == 0)) {
 944             fixedIntDigitCount = 1;
 945         }
 946         resultMax.setIntDigitCount(fixedIntDigitCount);
 947         resultMin.setIntDigitCount(fixedIntDigitCount);
 948     }
 949     // Spec says this is how we compute significant digits. 0 means
 950     // unlimited significant digits.
 951     int32_t maxSigDigits = minIntDigitCount + maxFracDigitCount;
 952     if (maxSigDigits > 0) {
 953         int32_t minSigDigits = minIntDigitCount + minFracDigitCount;
 954         resultSignificant.setMin(minSigDigits);
 955         resultSignificant.setMax(maxSigDigits);
 956     }
 957 }
 958
 959 void
 960 DecimalFormatImpl::updatePrecisionForScientific() {
 961     FixedPrecision *result = &fEffPrecision.fMantissa;
 962     if (fUseSigDigits) {
 963         result->fMax.setFracDigitCount(-1);
 964         result->fMax.setIntDigitCount(1);
 965         result->fMin.setFracDigitCount(0);
 966         result->fMin.setIntDigitCount(1);
 967         result->fSignificant.clear();
 968         extractSigDigits(result->fSignificant);
 969         return;
 970     }
 971     DigitInterval max;
 972     DigitInterval min;
 973     extractMinMaxDigits(min, max);
 974     updatePrecisionForScientificMinMax(
 975             min, max,
 976             result->fMin, result->fMax, result->fSignificant);
 977 }
 978
 979 void
 980 DecimalFormatImpl::updatePrecisionForFixed() {
 981     FixedPrecision *result = &fEffPrecision.fMantissa;
 982     if (!fUseSigDigits) {
 983         extractMinMaxDigits(result->fMin, result->fMax);
 984         result->fSignificant.clear();
 985     } else {
 986         extractSigDigits(result->fSignificant);
 987         result->fMin.setIntDigitCount(1);
 988         result->fMin.setFracDigitCount(0);
 989         result->fMax.clear();
 990     }
 991 }
 992
 993 void
 994  DecimalFormatImpl::extractMinMaxDigits(
 995         DigitInterval &min, DigitInterval &max) const {
 996     min.setIntDigitCount(fSuper->getMinimumIntegerDigits());
 997     max.setIntDigitCount(fSuper->getMaximumIntegerDigits());
 998     min.setFracDigitCount(fSuper->getMinimumFractionDigits());
 999     max.setFracDigitCount(fSuper->getMaximumFractionDigits());
1000 }
1001
1002 void
1003  DecimalFormatImpl::extractSigDigits(
1004         SignificantDigitInterval &sig) const {
1005     sig.setMin(fMinSigDigits < 0 ? 0 : fMinSigDigits);
1006     sig.setMax(fMaxSigDigits < 0 ? 0 : fMaxSigDigits);
1007 }
1008
1009 void
1010 DecimalFormatImpl::updateGrouping() {
1011     if (fSuper->isGroupingUsed()) {
1012         fEffGrouping = fGrouping;
1013     } else {
1014         fEffGrouping.clear();
1015     }
1016 }
1017
1018 void
1019 DecimalFormatImpl::updateCurrency(UErrorCode &status) {
1020     updateFormatting(kFormattingCurrency, TRUE, status);
1021 }
1022
1023 void
1024 DecimalFormatImpl::updateFormatting(
1025         int32_t changedFormattingFields,
1026         UErrorCode &status) {
1027     updateFormatting(changedFormattingFields, TRUE, status);
1028 }
1029
1030 void
1031 DecimalFormatImpl::updateFormatting(
1032         int32_t changedFormattingFields,
1033         UBool updatePrecisionBasedOnCurrency,
1034         UErrorCode &status) {
1035     if (U_FAILURE(status)) {
1036         return;
1037     }
1038     // Each function updates one field. Order matters. For instance,
1039     // updatePluralRules comes before updateCurrencyAffixInfo because the
1040     // fRules field is needed to update the fCurrencyAffixInfo field.
1041     updateFormattingUsesCurrency(changedFormattingFields);
1042     updateFormattingFixedPointFormatter(changedFormattingFields);
1043     updateFormattingAffixParser(changedFormattingFields);
1044     updateFormattingPluralRules(changedFormattingFields, status);
1045     updateFormattingCurrencyAffixInfo(
1046             changedFormattingFields,
1047             updatePrecisionBasedOnCurrency,
1048             status);
1049     updateFormattingLocalizedPositivePrefix(
1050             changedFormattingFields, status);
1051     updateFormattingLocalizedPositiveSuffix(
1052             changedFormattingFields, status);
1053     updateFormattingLocalizedNegativePrefix(
1054             changedFormattingFields, status);
1055     updateFormattingLocalizedNegativeSuffix(
1056             changedFormattingFields, status);
1057 }
1058
1059 void
1060 DecimalFormatImpl::updateFormattingUsesCurrency(
1061         int32_t &changedFormattingFields) {
1062     if ((changedFormattingFields & kFormattingAffixes) == 0) {
1063         // If no affixes changed, don't need to do any work
1064         return;
1065     }
1066     UBool newUsesCurrency =
1067             fPositivePrefixPattern.usesCurrency() ||
1068             fPositiveSuffixPattern.usesCurrency() ||
1069             fNegativePrefixPattern.usesCurrency() ||
1070             fNegativeSuffixPattern.usesCurrency();
1071     if (fMonetary != newUsesCurrency) {
1072         fMonetary = newUsesCurrency;
1073         changedFormattingFields |= kFormattingUsesCurrency;
1074     }
1075 }
1076
1077 void
1078 DecimalFormatImpl::updateFormattingPluralRules(
1079         int32_t &changedFormattingFields, UErrorCode &status) {
1080     if ((changedFormattingFields & (kFormattingSymbols | kFormattingUsesCurrency)) == 0) {
1081         // No work to do if both fSymbols and fMonetary
1082         // fields are unchanged
1083         return;
1084     }
1085     if (U_FAILURE(status)) {
1086         return;
1087     }
1088     PluralRules *newRules = NULL;
1089     if (fMonetary) {
1090         newRules = PluralRules::forLocale(fSymbols->getLocale(), status);
1091         if (U_FAILURE(status)) {
1092             return;
1093         }
1094     }
1095     // Its ok to say a field has changed when it really hasn't but not
1096     // the other way around. Here we assume the field changed unless it
1097     // was NULL before and is still NULL now
1098     if (fRules != newRules) {
1099         delete fRules;
1100         fRules = newRules;
1101         changedFormattingFields |= kFormattingPluralRules;
1102     }
1103 }
1104
1105 void
1106 DecimalFormatImpl::updateFormattingCurrencyAffixInfo(
1107         int32_t &changedFormattingFields,
1108         UBool updatePrecisionBasedOnCurrency,
1109         UErrorCode &status) {
1110     if ((changedFormattingFields & (
1111             kFormattingSymbols | kFormattingCurrency |
1112             kFormattingUsesCurrency | kFormattingPluralRules)) == 0) {
1113         // If all these fields are unchanged, no work to do.
1114         return;
1115     }
1116     if (U_FAILURE(status)) {
1117         return;
1118     }
1119     if (!fMonetary) {
1120         if (fCurrencyAffixInfo.isDefault()) {
1121             // In this case don't have to do any work
1122             return;
1123         }
1124         fCurrencyAffixInfo.set(NULL, NULL, NULL, status);
1125         if (U_FAILURE(status)) {
1126             return;
1127         }
1128         changedFormattingFields |= kFormattingCurrencyAffixInfo;
1129     } else {
1130         const UChar *currency = fSuper->getCurrency();
1131         UChar localeCurr[4];
1132         if (currency[0] == 0) {
1133             ucurr_forLocale(fSymbols->getLocale().getName(), localeCurr, UPRV_LENGTHOF(localeCurr), &status);
1134             if (U_SUCCESS(status)) {
1135                 currency = localeCurr;
1136                 fSuper->NumberFormat::setCurrency(currency, status);
1137             } else {
1138                 currency = NULL;
1139                 status = U_ZERO_ERROR;
1140             }
1141         }
1142         fCurrencyAffixInfo.set(
1143                 fSymbols->getLocale().getName(), fRules, currency, status);
1144         if (U_FAILURE(status)) {
1145             return;
1146         }
1147         UBool customCurrencySymbol = FALSE;
1148         // If DecimalFormatSymbols has custom currency symbol, prefer
1149         // that over what we just read from the resource bundles
1150         if (fSymbols->isCustomCurrencySymbol()) {
1151             fCurrencyAffixInfo.setSymbol(
1152                     fSymbols->getConstSymbol(DecimalFormatSymbols::kCurrencySymbol));
1153             customCurrencySymbol = TRUE;
1154         }
1155         if (fSymbols->isCustomIntlCurrencySymbol()) {
1156             fCurrencyAffixInfo.setISO(
1157                     fSymbols->getConstSymbol(DecimalFormatSymbols::kIntlCurrencySymbol));
1158             customCurrencySymbol = TRUE;
1159         }
1160         changedFormattingFields |= kFormattingCurrencyAffixInfo;
1161         if (currency && !customCurrencySymbol && updatePrecisionBasedOnCurrency) {
1162             FixedPrecision precision;
1163             CurrencyAffixInfo::adjustPrecision(
1164                     currency, fCurrencyUsage, precision, status);
1165             if (U_FAILURE(status)) {
1166                 return;
1167             }
1168             fSuper->NumberFormat::setMinimumFractionDigits(
1169                     precision.fMin.getFracDigitCount());
1170             fSuper->NumberFormat::setMaximumFractionDigits(
1171                     precision.fMax.getFracDigitCount());
1172             updatePrecision();
1173             fEffPrecision.fMantissa.fRoundingIncrement =
1174                     precision.fRoundingIncrement;
1175         }
1176
1177     }
1178 }
1179
1180 void
1181 DecimalFormatImpl::updateFormattingFixedPointFormatter(
1182         int32_t &changedFormattingFields) {
1183     if ((changedFormattingFields & (kFormattingSymbols | kFormattingUsesCurrency)) == 0) {
1184         // No work to do if fSymbols is unchanged
1185         return;
1186     }
1187     if (fMonetary) {
1188         fFormatter.setDecimalFormatSymbolsForMonetary(*fSymbols);
1189     } else {
1190         fFormatter.setDecimalFormatSymbols(*fSymbols);
1191     }
1192 }
1193
1194 void
1195 DecimalFormatImpl::updateFormattingAffixParser(
1196         int32_t &changedFormattingFields) {
1197     if ((changedFormattingFields & kFormattingSymbols) == 0) {
1198         // No work to do if fSymbols is unchanged
1199         return;
1200     }
1201     fAffixParser.setDecimalFormatSymbols(*fSymbols);
1202     changedFormattingFields |= kFormattingAffixParser;
1203 }
1204
1205 void
1206 DecimalFormatImpl::updateFormattingLocalizedPositivePrefix(
1207         int32_t &changedFormattingFields, UErrorCode &status) {
1208     if (U_FAILURE(status)) {
1209         return;
1210     }
1211     if ((changedFormattingFields & (
1212             kFormattingPosPrefix | kFormattingAffixParserWithCurrency)) == 0) {
1213         // No work to do
1214         return;
1215     }
1216     fAffixes.fPositivePrefix.remove();
1217     fAffixParser.parse(
1218             fPositivePrefixPattern,
1219             fCurrencyAffixInfo,
1220             fAffixes.fPositivePrefix,
1221             status);
1222 }
1223
1224 void
1225 DecimalFormatImpl::updateFormattingLocalizedPositiveSuffix(
1226         int32_t &changedFormattingFields, UErrorCode &status) {
1227     if (U_FAILURE(status)) {
1228         return;
1229     }
1230     if ((changedFormattingFields & (
1231             kFormattingPosSuffix | kFormattingAffixParserWithCurrency)) == 0) {
1232         // No work to do
1233         return;
1234     }
1235     fAffixes.fPositiveSuffix.remove();
1236     fAffixParser.parse(
1237             fPositiveSuffixPattern,
1238             fCurrencyAffixInfo,
1239             fAffixes.fPositiveSuffix,
1240             status);
1241 }
1242
1243 void
1244 DecimalFormatImpl::updateFormattingLocalizedNegativePrefix(
1245         int32_t &changedFormattingFields, UErrorCode &status) {
1246     if (U_FAILURE(status)) {
1247         return;
1248     }
1249     if ((changedFormattingFields & (
1250             kFormattingNegPrefix | kFormattingAffixParserWithCurrency)) == 0) {
1251         // No work to do
1252         return;
1253     }
1254     fAffixes.fNegativePrefix.remove();
1255     fAffixParser.parse(
1256             fNegativePrefixPattern,
1257             fCurrencyAffixInfo,
1258             fAffixes.fNegativePrefix,
1259             status);
1260 }
1261
1262 void
1263 DecimalFormatImpl::updateFormattingLocalizedNegativeSuffix(
1264         int32_t &changedFormattingFields, UErrorCode &status) {
1265     if (U_FAILURE(status)) {
1266         return;
1267     }
1268     if ((changedFormattingFields & (
1269             kFormattingNegSuffix | kFormattingAffixParserWithCurrency)) == 0) {
1270         // No work to do
1271         return;
1272     }
1273     fAffixes.fNegativeSuffix.remove();
1274     fAffixParser.parse(
1275             fNegativeSuffixPattern,
1276             fCurrencyAffixInfo,
1277             fAffixes.fNegativeSuffix,
1278             status);
1279 }
1280
1281 void
1282 DecimalFormatImpl::updateForApplyPatternFavorCurrencyPrecision(
1283         UErrorCode &status) {
1284     updateAll(kFormattingAll & ~kFormattingSymbols, TRUE, status);
1285 }
1286
1287 void
1288 DecimalFormatImpl::updateForApplyPattern(UErrorCode &status) {
1289     updateAll(kFormattingAll & ~kFormattingSymbols, FALSE, status);
1290 }
1291
1292 void
1293 DecimalFormatImpl::updateAll(UErrorCode &status) {
1294     updateAll(kFormattingAll, TRUE, status);
1295 }
1296
1297 void
1298 DecimalFormatImpl::updateAll(
1299         int32_t formattingFlags,
1300         UBool updatePrecisionBasedOnCurrency,
1301         UErrorCode &status) {
1302     if (U_FAILURE(status)) {
1303         return;
1304     }
1305     updatePrecision();
1306     updateGrouping();
1307     updateFormatting(
1308             formattingFlags, updatePrecisionBasedOnCurrency, status);
1309     setMultiplierScale(getPatternScale());
1310 }
1311
1312
1313 static int32_t
1314 getMinimumLengthToDescribeGrouping(const DigitGrouping &grouping) {
1315     if (grouping.fGrouping <= 0) {
1316         return 0;
1317     }
1318     if (grouping.fGrouping2 <= 0) {
1319         return grouping.fGrouping + 1;
1320     }
1321     return grouping.fGrouping + grouping.fGrouping2 + 1;
1322 }
1323
1324 /**
1325  * Given a grouping policy, calculates how many digits are needed left of
1326  * the decimal point to achieve a desired length left of the
1327  * decimal point.
1328  * @param grouping the grouping policy
1329  * @param desiredLength number of characters needed left of decimal point
1330  * @param minLeftDigits at least this many digits is returned
1331  * @param leftDigits the number of digits needed stored here
1332  *  which is >= minLeftDigits.
1333  * @return true if a perfect fit or false if having leftDigits would exceed
1334  *   desiredLength
1335  */
1336 static UBool
1337 getLeftDigitsForLeftLength(
1338         const DigitGrouping &grouping,
1339         int32_t desiredLength,
1340         int32_t minLeftDigits,
1341         int32_t &leftDigits) {
1342     leftDigits = minLeftDigits;
1343     int32_t lengthSoFar = leftDigits + grouping.getSeparatorCount(leftDigits);
1344     while (lengthSoFar < desiredLength) {
1345         lengthSoFar += grouping.isSeparatorAt(leftDigits + 1, leftDigits) ? 2 : 1;
1346         ++leftDigits;
1347     }
1348     return (lengthSoFar == desiredLength);
1349 }
1350
1351 int32_t
1352 DecimalFormatImpl::computeExponentPatternLength() const {
1353     if (fUseScientific) {
1354         return 1 + (fOptions.fExponent.fAlwaysShowSign ? 1 : 0) + fEffPrecision.fMinExponentDigits;
1355     }
1356     return 0;
1357 }
1358
1359 int32_t
1360 DecimalFormatImpl::countFractionDigitAndDecimalPatternLength(
1361         int32_t fracDigitCount) const {
1362     if (!fOptions.fMantissa.fAlwaysShowDecimal && fracDigitCount == 0) {
1363         return 0;
1364     }
1365     return fracDigitCount + 1;
1366 }
1367
1368 UnicodeString&
1369 DecimalFormatImpl::toNumberPattern(
1370         UBool hasPadding, int32_t minimumLength, UnicodeString& result) const {
1371     // Get a grouping policy like the one in this object that does not
1372     // have minimum grouping since toPattern doesn't support it.
1373     DigitGrouping grouping(fEffGrouping);
1374     grouping.fMinGrouping = 0;
1375
1376     // Only for fixed digits, these are the digits that get 0's.
1377     DigitInterval minInterval;
1378
1379     // Only for fixed digits, these are the digits that get #'s.
1380     DigitInterval maxInterval;
1381
1382     // Only for significant digits
1383     int32_t sigMin;
1384     int32_t sigMax;
1385
1386     // These are all the digits to be displayed. For significant digits,
1387     // this interval always starts at the 1's place an extends left.
1388     DigitInterval fullInterval;
1389
1390     // Digit range of rounding increment. If rounding increment is .025.
1391     // then roundingIncrementLowerExp = -3 and roundingIncrementUpperExp = -1
1392     int32_t roundingIncrementLowerExp = 0;
1393     int32_t roundingIncrementUpperExp = 0;
1394
1395     if (fUseSigDigits) {
1396         SignificantDigitInterval sigInterval;
1397         extractSigDigits(sigInterval);
1398         sigMax = sigInterval.getMax();
1399         sigMin = sigInterval.getMin();
1400         fullInterval.setFracDigitCount(0);
1401         fullInterval.setIntDigitCount(sigMax);
1402     } else {
1403         extractMinMaxDigits(minInterval, maxInterval);
1404         if (fUseScientific) {
1405            if (maxInterval.getIntDigitCount() > kMaxScientificIntegerDigits) {
1406                maxInterval.setIntDigitCount(1);
1407                minInterval.shrinkToFitWithin(maxInterval);
1408            }
1409         } else if (hasPadding) {
1410             // Make max int digits match min int digits for now, we
1411             // compute necessary padding later.
1412             maxInterval.setIntDigitCount(minInterval.getIntDigitCount());
1413         } else {
1414             // For some reason toPattern adds at least one leading '#'
1415             maxInterval.setIntDigitCount(minInterval.getIntDigitCount() + 1);
1416         }
1417         if (!fEffPrecision.fMantissa.fRoundingIncrement.isZero()) {
1418             roundingIncrementLowerExp =
1419                     fEffPrecision.fMantissa.fRoundingIncrement.getLowerExponent();
1420             roundingIncrementUpperExp =
1421                     fEffPrecision.fMantissa.fRoundingIncrement.getUpperExponent();
1422             // We have to include the rounding increment in what we display
1423             maxInterval.expandToContainDigit(roundingIncrementLowerExp);
1424             maxInterval.expandToContainDigit(roundingIncrementUpperExp - 1);
1425         }
1426         fullInterval = maxInterval;
1427     }
1428     // We have to include enough digits to show grouping strategy
1429     int32_t minLengthToDescribeGrouping =
1430            getMinimumLengthToDescribeGrouping(grouping);
1431     if (minLengthToDescribeGrouping > 0) {
1432         fullInterval.expandToContainDigit(
1433                 getMinimumLengthToDescribeGrouping(grouping) - 1);
1434     }
1435
1436     // If we have a minimum length, we have to add digits to the left to
1437     // depict padding.
1438     if (hasPadding) {
1439         // For non scientific notation,
1440         //  minimumLengthForMantissa = minimumLength
1441         int32_t minimumLengthForMantissa =
1442                 minimumLength - computeExponentPatternLength();
1443         int32_t mininumLengthForMantissaIntPart =
1444                 minimumLengthForMantissa
1445                 - countFractionDigitAndDecimalPatternLength(
1446                         fullInterval.getFracDigitCount());
1447         // Because of grouping, we may need fewer than expected digits to
1448         // achieve the length we need.
1449         int32_t digitsNeeded;
1450         if (getLeftDigitsForLeftLength(
1451                 grouping,
1452                 mininumLengthForMantissaIntPart,
1453                 fullInterval.getIntDigitCount(),
1454                 digitsNeeded)) {
1455
1456             // In this case, we achieved the exact length that we want.
1457             fullInterval.setIntDigitCount(digitsNeeded);
1458         } else if (digitsNeeded > fullInterval.getIntDigitCount()) {
1459
1460             // Having digitsNeeded digits goes over desired length which
1461             // means that to have desired length would mean starting on a
1462             // grouping sepearator e.g ,###,### so add a '#' and use one
1463             // less digit. This trick gives ####,### but that is the best
1464             // we can do.
1465             result.append(kPatternDigit);
1466             fullInterval.setIntDigitCount(digitsNeeded - 1);
1467         }
1468     }
1469     int32_t maxDigitPos = fullInterval.getMostSignificantExclusive();
1470     int32_t minDigitPos = fullInterval.getLeastSignificantInclusive();
1471     for (int32_t i = maxDigitPos - 1; i >= minDigitPos; --i) {
1472         if (!fOptions.fMantissa.fAlwaysShowDecimal && i == -1) {
1473             result.append(kPatternDecimalSeparator);
1474         }
1475         if (fUseSigDigits) {
1476             // Use digit symbol
1477             if (i >= sigMax || i < sigMax - sigMin) {
1478                 result.append(kPatternDigit);
1479             } else {
1480                 result.append(kPatternSignificantDigit);
1481             }
1482         } else {
1483             if (i < roundingIncrementUpperExp && i >= roundingIncrementLowerExp) {
1484                 result.append(fEffPrecision.fMantissa.fRoundingIncrement.getDigitByExponent(i) + kPatternZeroDigit);
1485             } else if (minInterval.contains(i)) {
1486                 result.append(kPatternZeroDigit);
1487             } else {
1488                 result.append(kPatternDigit);
1489             }
1490         }
1491         if (grouping.isSeparatorAt(i + 1, i)) {
1492             result.append(kPatternGroupingSeparator);
1493         }
1494         if (fOptions.fMantissa.fAlwaysShowDecimal && i == 0) {
1495             result.append(kPatternDecimalSeparator);
1496         }
1497     }
1498     if (fUseScientific) {
1499         result.append(kPatternExponent);
1500         if (fOptions.fExponent.fAlwaysShowSign) {
1501             result.append(kPatternPlus);
1502         }
1503         for (int32_t i = 0; i < 1 || i < fEffPrecision.fMinExponentDigits; ++i) {
1504             result.append(kPatternZeroDigit);
1505         }
1506     }
1507     return result;
1508 }
1509
1510 UnicodeString&
1511 DecimalFormatImpl::toPattern(UnicodeString& result) const {
1512     result.remove();
1513     UnicodeString padSpec;
1514     if (fAffixes.fWidth > 0) {
1515         padSpec.append(kPatternPadEscape);
1516         padSpec.append(fAffixes.fPadChar);
1517     }
1518     if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforePrefix) {
1519         result.append(padSpec);
1520     }
1521     fPositivePrefixPattern.toUserString(result);
1522     if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterPrefix) {
1523         result.append(padSpec);
1524     }
1525     toNumberPattern(
1526             fAffixes.fWidth > 0,
1527             fAffixes.fWidth - fPositivePrefixPattern.countChar32() - fPositiveSuffixPattern.countChar32(),
1528             result);
1529     if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforeSuffix) {
1530         result.append(padSpec);
1531     }
1532     fPositiveSuffixPattern.toUserString(result);
1533     if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterSuffix) {
1534         result.append(padSpec);
1535     }
1536     AffixPattern withNegative;
1537     withNegative.add(AffixPattern::kNegative);
1538     withNegative.append(fPositivePrefixPattern);
1539     if (!fPositiveSuffixPattern.equals(fNegativeSuffixPattern) ||
1540             !withNegative.equals(fNegativePrefixPattern)) {
1541         result.append(kPatternSeparator);
1542         if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforePrefix) {
1543             result.append(padSpec);
1544         }
1545         fNegativePrefixPattern.toUserString(result);
1546         if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterPrefix) {
1547             result.append(padSpec);
1548         }
1549         toNumberPattern(
1550                 fAffixes.fWidth > 0,
1551                 fAffixes.fWidth - fNegativePrefixPattern.countChar32() - fNegativeSuffixPattern.countChar32(),
1552                 result);
1553         if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforeSuffix) {
1554             result.append(padSpec);
1555         }
1556         fNegativeSuffixPattern.toUserString(result);
1557         if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterSuffix) {
1558             result.append(padSpec);
1559         }
1560     }
1561     return result;
1562 }
1563
1564 int32_t
1565 DecimalFormatImpl::getOldFormatWidth() const {
1566     if (fAffixes.fWidth == 0) {
1567         return 0;
1568     }
1569     return fAffixes.fWidth - fPositiveSuffixPattern.countChar32() - fPositivePrefixPattern.countChar32();
1570 }
1571
1572 const UnicodeString &
1573 DecimalFormatImpl::getConstSymbol(
1574         DecimalFormatSymbols::ENumberFormatSymbol symbol) const {
1575    return fSymbols->getConstSymbol(symbol);
1576 }
1577
1578 UBool
1579 DecimalFormatImpl::isParseFastpath() const {
1580     AffixPattern negative;
1581     negative.add(AffixPattern::kNegative);
1582
1583     return fAffixes.fWidth == 0 &&
1584     fPositivePrefixPattern.countChar32() == 0 &&
1585     fNegativePrefixPattern.equals(negative) &&
1586     fPositiveSuffixPattern.countChar32() == 0 &&
1587     fNegativeSuffixPattern.countChar32() == 0;
1588 }
1589
1590
1591 U_NAMESPACE_END
1592
1593 #endif /* #if !UCONFIG_NO_FORMATTING */
1594