icuSources/i18n/decimfmtimpl.h

   1 /*
   2 ********************************************************************************
   3 *   Copyright (C) 2015, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 ********************************************************************************
   6 *
   7 * File decimfmtimpl.h
   8 ********************************************************************************
   9 */
  10
  11 #ifndef DECIMFMTIMPL_H
  12 #define DECIMFMTIMPL_H
  13
  14 #include "unicode/utypes.h"
  15
  16 #if !UCONFIG_NO_FORMATTING
  17
  18 #include "unicode/decimfmt.h"
  19 #include "unicode/uobject.h"
  20 #include "affixpatternparser.h"
  21 #include "digitaffixesandpadding.h"
  22 #include "digitformatter.h"
  23 #include "digitgrouping.h"
  24 #include "precision.h"
  25
  26 U_NAMESPACE_BEGIN
  27
  28 class UnicodeString;
  29 class FieldPosition;
  30 class ValueFormatter;
  31 class FieldPositionHandler;
  32 class FixedDecimal;
  33
  34 /**
  35  * DecimalFormatImpl is the glue code between the legacy DecimalFormat class
  36  * and the new decimal formatting classes. DecimalFormat still handles
  37  * parsing directly. However, DecimalFormat uses attributes of this class
  38  * for parsing when possible.
  39  *
  40  * The public API of this class closely mirrors the legacy API of the
  41  * legacy DecimalFormat deviating only when the legacy API does not make
  42  * sense. For example, although DecimalFormat has a
  43  * getPadCharacterString() method, DecimalFormatImpl has a getPadCharacter()
  44  * method because formatting uses only a single pad character for padding.
  45  *
  46  * Each legacy DecimalFormat instance heap allocates its own instance of
  47  * this class. Most DecimalFormat methods that deal with formatting simply
  48  * delegate to the DecimalFormat's DecimalFormatImpl method.
  49  *
  50  * Because DecimalFormat extends NumberFormat, Each instance of this class
  51  * "borrows" a pointer to the NumberFormat part of its enclosing DecimalFormat
  52  * instance. This way each DecimalFormatImpl instance can read or even modify
  53  * the NumberFormat portion of its enclosing DecimalFormat instance.
  54  *
  55  * Directed acyclic graph (DAG):
  56  *
  57  * This class can be represented as a directed acyclic graph (DAG) where each
  58  * vertex is an attribute, and each directed edge indicates that the value
  59  * of the destination attribute is calculated from the value of the source
  60  * attribute. Attributes with setter methods reside at the bottom of the
  61  * DAG. That is, no edges point to them. We call these independent attributes
  62  * because their values can be set independently of one another. The rest of
  63  * the attributes are derived attributes because their values depend on the
  64  * independent attributes. DecimalFormatImpl often uses the derived
  65  * attributes, not the independent attributes, when formatting numbers.
  66  *
  67  * The independent attributes at the bottom of the DAG correspond to the legacy
  68  * attributes of DecimalFormat while the attributes at the top of the DAG
  69  * correspond to the attributes of the new code. The edges of the DAG
  70  * correspond to the code that handles the complex interaction among all the
  71  * legacy attributes of the DecimalFormat API.
  72  *
  73  * We use a DAG for three reasons.
  74  *
  75  * First, the DAG preserves backward compatibility. Clients of the legacy
  76  * DecimalFormat expect existing getters and setters of each attribute to be
  77  * consistent. That means if a client sets a particular attribute to a new
  78  * value, the attribute should retain that value until the client sets it to
  79  * a new value. The DAG allows these attributes to remain consistent even
  80  * though the new code may not use them when formatting.
  81  *
  82  * Second, the DAG obviates the need to recalculate derived attributes with
  83  * each format. Instead, the DAG "remembers" the values of all derived
  84  * attributes. Only setting an independent attribute requires a recalculation.
  85  * Moreover, setting an independent attribute recalculates only the affected
  86  * dependent attributes rather than all dependent attributes.
  87  *
  88  * Third, the DAG abstracts away the complex interaction among the legacy
  89  * attributes of the DecimalFormat API.
  90  *
  91  * Only the independent attributes of the DAG have setters and getters.
  92  * Derived attributes have no setters (and often no getters either).
  93  *
  94  * Copy and assign:
  95  *
  96  * For copy and assign, DecimalFormatImpl copies and assigns every attribute
  97  * regardless of whether or not it is independent. We do this for simplicity.
  98  *
  99  * Implementation of the DAG:
 100  *
 101  * The DAG consists of three smaller DAGs:
 102  * 1. Grouping attributes
 103  * 2. Precision attributes
 104  * 3. Formatting attributes.
 105  *
 106  * The first two DAGs are simple in that setting any independent attribute
 107  * in the DAG recalculates all the dependent attributes in that DAG.
 108  * The updateGrouping() and updatePrecision() perform the respective
 109  * recalculations.
 110  *
 111  * Because some of the derived formatting attributes are expensive to
 112  * calculate, the formatting attributes DAG is more complex. The
 113  * updateFormatting() method is composed of many updateFormattingXXX()
 114  * methods, each of which recalculates a single derived attribute. The
 115  * updateFormatting() method accepts a bitfield of recently changed
 116  * attributes and passes this bitfield by reference to each of the
 117  * updateFormattingXXX() methods. Each updateFormattingXXX() method checks
 118  * the bitfield to see if any of the attributes it uses to compute the XXX
 119  * attribute changed. If none of them changed, it exists immediately. However,
 120  * if at least one of them changed, it recalculates the XXX attribute and
 121  * sets the corresponding bit in the bitfield. In this way, each
 122  * updateFormattingXXX() method encodes the directed edges in the formatting
 123  * DAG that point to the attribute its calculating.
 124  *
 125  * Maintenance of the updateFormatting() method.
 126  *
 127  * Use care when changing the updateFormatting() method.
 128  * The updateFormatting() method must call each updateFormattingXXX() in the
 129  * same partial order that the formatting DAG prescribes. That is, the
 130  * attributes near the bottom of the DAG must be calculated before attributes
 131  * further up. As we mentioned in the prvious paragraph, the directed edges of
 132  * the formatting DAG are encoded within each updateFormattingXXX() method.
 133  * Finally, adding new attributes may involve adding to the bitmap that the
 134  * updateFormatting() method uses. The top most attributes in the DAG,
 135  * those that do not point to any attributes but only have attributes
 136  * pointing to it, need not have a slot in the bitmap.
 137  *
 138  * Keep in mind that most of the code that makes the legacy DecimalFormat API
 139  * work the way it always has before can be found in these various updateXXX()
 140  * methods. For example the updatePrecisionForScientific() method
 141  * handles the complex interactions amoung the various precision attributes
 142  * when formatting in scientific notation. Changing the way attributes
 143  * interract, often means changing one of these updateXXX() methods.
 144  *
 145  * Conclusion:
 146  *
 147  * The DecimFmtImpl class is the glue code between the legacy and new
 148  * number formatting code. It uses a direct acyclic graph (DAG) to
 149  * maintain backward compatibility, to make the code efficient, and to
 150  * abstract away the complex interraction among legacy attributs.
 151  */
 152
 153
 154 class DecimalFormatImpl : public UObject {
 155 public:
 156
 157 DecimalFormatImpl(
 158         NumberFormat *super,
 159         const Locale &locale,
 160         const UnicodeString &pattern,
 161         UErrorCode &status);
 162 DecimalFormatImpl(
 163         NumberFormat *super,
 164         const UnicodeString &pattern,
 165         DecimalFormatSymbols *symbolsToAdopt,
 166         UParseError &parseError,
 167         UErrorCode &status);
 168 DecimalFormatImpl(
 169         NumberFormat *super,
 170         const DecimalFormatImpl &other,
 171         UErrorCode &status);
 172 DecimalFormatImpl &assign(
 173         const DecimalFormatImpl &other, UErrorCode &status);
 174 virtual ~DecimalFormatImpl();
 175 void adoptDecimalFormatSymbols(DecimalFormatSymbols *symbolsToAdopt);
 176 const DecimalFormatSymbols &getDecimalFormatSymbols() const {
 177     return *fSymbols;
 178 }
 179 UnicodeString &format(
 180         int32_t number,
 181         UnicodeString &appendTo,
 182         FieldPosition &pos,
 183         UErrorCode &status) const;
 184 UnicodeString &format(
 185         int32_t number,
 186         UnicodeString &appendTo,
 187         FieldPositionIterator *posIter,
 188         UErrorCode &status) const;
 189 UnicodeString &format(
 190         int64_t number,
 191         UnicodeString &appendTo,
 192         FieldPosition &pos,
 193         UErrorCode &status) const;
 194 UnicodeString &format(
 195         double number,
 196         UnicodeString &appendTo,
 197         FieldPosition &pos,
 198         UErrorCode &status) const;
 199 UnicodeString &format(
 200         const DigitList &number,
 201         UnicodeString &appendTo,
 202         FieldPosition &pos,
 203         UErrorCode &status) const;
 204 UnicodeString &format(
 205         int64_t number,
 206         UnicodeString &appendTo,
 207         FieldPositionIterator *posIter,
 208         UErrorCode &status) const;
 209 UnicodeString &format(
 210         double number,
 211         UnicodeString &appendTo,
 212         FieldPositionIterator *posIter,
 213         UErrorCode &status) const;
 214 UnicodeString &format(
 215         const DigitList &number,
 216         UnicodeString &appendTo,
 217         FieldPositionIterator *posIter,
 218         UErrorCode &status) const;
 219 UnicodeString &format(
 220         const StringPiece &number,
 221         UnicodeString &appendTo,
 222         FieldPositionIterator *posIter,
 223         UErrorCode &status) const;
 224 UnicodeString &format(
 225         const VisibleDigitsWithExponent &digits,
 226         UnicodeString &appendTo,
 227         FieldPosition &pos,
 228         UErrorCode &status) const;
 229 UnicodeString &format(
 230         const VisibleDigitsWithExponent &digits,
 231         UnicodeString &appendTo,
 232         FieldPositionIterator *posIter,
 233         UErrorCode &status) const;
 234
 235 UBool operator==(const DecimalFormatImpl &) const;
 236
 237 UBool operator!=(const DecimalFormatImpl &other) const {
 238     return !(*this == other);
 239 }
 240
 241 void setRoundingMode(DecimalFormat::ERoundingMode mode) {
 242     fRoundingMode = mode;
 243     fEffPrecision.fMantissa.fExactOnly = (fRoundingMode == DecimalFormat::kRoundUnnecessary);
 244     fEffPrecision.fMantissa.fRoundingMode = mode;
 245 }
 246 DecimalFormat::ERoundingMode getRoundingMode() const {
 247     return fRoundingMode;
 248 }
 249 void setFailIfMoreThanMaxDigits(UBool b) {
 250     fEffPrecision.fMantissa.fFailIfOverMax = b;
 251 }
 252 UBool isFailIfMoreThanMaxDigits() const { return fEffPrecision.fMantissa.fFailIfOverMax; }
 253 void setMinimumSignificantDigits(int32_t newValue);
 254 void setMaximumSignificantDigits(int32_t newValue);
 255 void setMinMaxSignificantDigits(int32_t min, int32_t max);
 256 void setScientificNotation(UBool newValue);
 257 void setSignificantDigitsUsed(UBool newValue);
 258
 259 int32_t getMinimumSignificantDigits() const {
 260         return fMinSigDigits; }
 261 int32_t getMaximumSignificantDigits() const {
 262         return fMaxSigDigits; }
 263 UBool isScientificNotation() const { return fUseScientific; }
 264 UBool areSignificantDigitsUsed() const { return fUseSigDigits; }
 265 void setGroupingSize(int32_t newValue);
 266 void setSecondaryGroupingSize(int32_t newValue);
 267 void setMinimumGroupingDigits(int32_t newValue);
 268 int32_t getGroupingSize() const { return fGrouping.fGrouping; }
 269 int32_t getSecondaryGroupingSize() const { return fGrouping.fGrouping2; }
 270 int32_t getMinimumGroupingDigits() const { return fGrouping.fMinGrouping; }
 271 void applyPattern(const UnicodeString &pattern, UErrorCode &status);
 272 void applyPatternFavorCurrencyPrecision(
 273         const UnicodeString &pattern, UErrorCode &status);
 274 void applyPattern(
 275         const UnicodeString &pattern, UParseError &perror, UErrorCode &status);
 276 void applyLocalizedPattern(const UnicodeString &pattern, UErrorCode &status);
 277 void applyLocalizedPattern(
 278         const UnicodeString &pattern, UParseError &perror, UErrorCode &status);
 279 void setCurrencyUsage(UCurrencyUsage usage, UErrorCode &status);
 280 UCurrencyUsage getCurrencyUsage() const { return fCurrencyUsage; }
 281 void setRoundingIncrement(double d);
 282 double getRoundingIncrement() const;
 283 int32_t getMultiplier() const;
 284 void setMultiplier(int32_t m);
 285 UChar32 getPadCharacter() const { return fAffixes.fPadChar; }
 286 void setPadCharacter(UChar32 c) { fAffixes.fPadChar = c; }
 287 int32_t getFormatWidth() const { return fAffixes.fWidth; }
 288 void setFormatWidth(int32_t x) { fAffixes.fWidth = x; }
 289 DigitAffixesAndPadding::EPadPosition getPadPosition() const {
 290     return fAffixes.fPadPosition;
 291 }
 292 void setPadPosition(DigitAffixesAndPadding::EPadPosition x) {
 293     fAffixes.fPadPosition = x;
 294 }
 295 int32_t getMinimumExponentDigits() const {
 296     return fEffPrecision.fMinExponentDigits;
 297 }
 298 void setMinimumExponentDigits(int32_t x) {
 299     fEffPrecision.fMinExponentDigits = x;
 300 }
 301 UBool isExponentSignAlwaysShown() const {
 302     return fOptions.fExponent.fAlwaysShowSign;
 303 }
 304 void setExponentSignAlwaysShown(UBool x) {
 305     fOptions.fExponent.fAlwaysShowSign = x;
 306 }
 307 UBool isDecimalSeparatorAlwaysShown() const {
 308     return fOptions.fMantissa.fAlwaysShowDecimal;
 309 }
 310 void setDecimalSeparatorAlwaysShown(UBool x) {
 311     fOptions.fMantissa.fAlwaysShowDecimal = x;
 312 }
 313 UnicodeString &getPositivePrefix(UnicodeString &result) const;
 314 UnicodeString &getPositiveSuffix(UnicodeString &result) const;
 315 UnicodeString &getNegativePrefix(UnicodeString &result) const;
 316 UnicodeString &getNegativeSuffix(UnicodeString &result) const;
 317 void setPositivePrefix(const UnicodeString &str);
 318 void setPositiveSuffix(const UnicodeString &str);
 319 void setNegativePrefix(const UnicodeString &str);
 320 void setNegativeSuffix(const UnicodeString &str);
 321 UnicodeString &toPattern(UnicodeString& result) const;
 322 FixedDecimal &getFixedDecimal(double value, FixedDecimal &result, UErrorCode &status) const;
 323 FixedDecimal &getFixedDecimal(DigitList &number, FixedDecimal &result, UErrorCode &status) const;
 324 DigitList &round(DigitList &number, UErrorCode &status) const;
 325
 326 VisibleDigitsWithExponent &
 327 initVisibleDigitsWithExponent(
 328         int64_t number,
 329         VisibleDigitsWithExponent &digits,
 330         UErrorCode &status) const;
 331 VisibleDigitsWithExponent &
 332 initVisibleDigitsWithExponent(
 333         double number,
 334         VisibleDigitsWithExponent &digits,
 335         UErrorCode &status) const;
 336 VisibleDigitsWithExponent &
 337 initVisibleDigitsWithExponent(
 338         DigitList &number,
 339         VisibleDigitsWithExponent &digits,
 340         UErrorCode &status) const;
 341
 342 void updatePrecision();
 343 void updateGrouping();
 344 void updateCurrency(UErrorCode &status);
 345
 346
 347 private:
 348 // Disallow copy and assign
 349 DecimalFormatImpl(const DecimalFormatImpl &other);
 350 DecimalFormatImpl &operator=(const DecimalFormatImpl &other);
 351 NumberFormat *fSuper;
 352 DigitList fMultiplier;
 353 int32_t fScale;
 354
 355 DecimalFormat::ERoundingMode fRoundingMode;
 356
 357 // These fields include what the user can see and set.
 358 // When the user updates these fields, it triggers automatic updates of
 359 // other fields that may be invisible to user
 360
 361 // Updating any of the following fields triggers an update to
 362 // fEffPrecision.fMantissa.fMin,
 363 // fEffPrecision.fMantissa.fMax,
 364 // fEffPrecision.fMantissa.fSignificant fields
 365 // We have this two phase update because of backward compatibility.
 366 // DecimalFormat has to remember all settings even if those settings are
 367 // invalid or disabled.
 368 int32_t fMinSigDigits;
 369 int32_t fMaxSigDigits;
 370 UBool fUseScientific;
 371 UBool fUseSigDigits;
 372 // In addition to these listed above, changes to min/max int digits and
 373 // min/max frac digits from fSuper also trigger an update.
 374
 375 // Updating any of the following fields triggers an update to
 376 // fEffGrouping field Again we do it this way because original
 377 // grouping settings have to be retained if grouping is turned off.
 378 DigitGrouping fGrouping;
 379 // In addition to these listed above, changes to isGroupingUsed in
 380 // fSuper also triggers an update to fEffGrouping.
 381
 382 // Updating any of the following fields triggers updates on the following:
 383 // fMonetary, fRules, fAffixParser, fCurrencyAffixInfo,
 384 // fFormatter, fAffixes.fPositivePrefiix, fAffixes.fPositiveSuffix,
 385 // fAffixes.fNegativePrefiix, fAffixes.fNegativeSuffix
 386 // We do this two phase update because localizing the affix patterns
 387 // and formatters can be expensive. Better to do it once with the setters
 388 // than each time within format.
 389 AffixPattern fPositivePrefixPattern;
 390 AffixPattern fNegativePrefixPattern;
 391 AffixPattern fPositiveSuffixPattern;
 392 AffixPattern fNegativeSuffixPattern;
 393 DecimalFormatSymbols *fSymbols;
 394 UCurrencyUsage fCurrencyUsage;
 395 // In addition to these listed above, changes to getCurrency() in
 396 // fSuper also triggers an update.
 397
 398 // Optional may be NULL
 399 PluralRules *fRules;
 400
 401 // These fields are totally hidden from user and are used to derive the affixes
 402 // in fAffixes below from the four affix patterns above.
 403 UBool fMonetary;
 404 AffixPatternParser fAffixParser;
 405 CurrencyAffixInfo fCurrencyAffixInfo;
 406
 407 // The actual precision used when formatting
 408 ScientificPrecision fEffPrecision;
 409
 410 // The actual grouping used when formatting
 411 DigitGrouping fEffGrouping;
 412 SciFormatterOptions fOptions;   // Encapsulates fixed precision options
 413 DigitFormatter fFormatter;
 414 DigitAffixesAndPadding fAffixes;
 415
 416 UnicodeString &formatInt32(
 417         int32_t number,
 418         UnicodeString &appendTo,
 419         FieldPositionHandler &handler,
 420         UErrorCode &status) const;
 421
 422 UnicodeString &formatInt64(
 423         int64_t number,
 424         UnicodeString &appendTo,
 425         FieldPositionHandler &handler,
 426         UErrorCode &status) const;
 427
 428 UnicodeString &formatDouble(
 429         double number,
 430         UnicodeString &appendTo,
 431         FieldPositionHandler &handler,
 432         UErrorCode &status) const;
 433
 434 // Scales for precent or permille symbols
 435 UnicodeString &formatDigitList(
 436         DigitList &number,
 437         UnicodeString &appendTo,
 438         FieldPositionHandler &handler,
 439         UErrorCode &status) const;
 440
 441 // Does not scale for precent or permille symbols
 442 UnicodeString &formatAdjustedDigitList(
 443         DigitList &number,
 444         UnicodeString &appendTo,
 445         FieldPositionHandler &handler,
 446         UErrorCode &status) const;
 447
 448 UnicodeString &formatVisibleDigitsWithExponent(
 449         const VisibleDigitsWithExponent &number,
 450         UnicodeString &appendTo,
 451         FieldPositionHandler &handler,
 452         UErrorCode &status) const;
 453
 454 VisibleDigitsWithExponent &
 455 initVisibleDigitsFromAdjusted(
 456         DigitList &number,
 457         VisibleDigitsWithExponent &digits,
 458         UErrorCode &status) const;
 459
 460 template<class T>
 461 UBool maybeFormatWithDigitList(
 462         T number,
 463         UnicodeString &appendTo,
 464         FieldPositionHandler &handler,
 465         UErrorCode &status) const;
 466
 467 template<class T>
 468 UBool maybeInitVisibleDigitsFromDigitList(
 469         T number,
 470         VisibleDigitsWithExponent &digits,
 471         UErrorCode &status) const;
 472
 473 DigitList &adjustDigitList(DigitList &number, UErrorCode &status) const;
 474
 475 void applyPattern(
 476         const UnicodeString &pattern,
 477         UBool localized, UParseError &perror, UErrorCode &status);
 478
 479 ValueFormatter &prepareValueFormatter(ValueFormatter &vf) const;
 480 void setMultiplierScale(int32_t s);
 481 int32_t getPatternScale() const;
 482 void setScale(int32_t s) { fScale = s; }
 483 int32_t getScale() const { return fScale; }
 484
 485 // Updates everything
 486 void updateAll(UErrorCode &status);
 487 void updateAll(
 488         int32_t formattingFlags,
 489         UBool updatePrecisionBasedOnCurrency,
 490         UErrorCode &status);
 491
 492 // Updates from formatting pattern changes
 493 void updateForApplyPattern(UErrorCode &status);
 494 void updateForApplyPatternFavorCurrencyPrecision(UErrorCode &status);
 495
 496 // Updates from changes to third group of attributes
 497 void updateFormatting(int32_t changedFormattingFields, UErrorCode &status);
 498 void updateFormatting(
 499         int32_t changedFormattingFields,
 500         UBool updatePrecisionBasedOnCurrency,
 501         UErrorCode &status);
 502
 503 // Helper functions for updatePrecision
 504 void updatePrecisionForScientific();
 505 void updatePrecisionForFixed();
 506 void extractMinMaxDigits(DigitInterval &min, DigitInterval &max) const;
 507 void extractSigDigits(SignificantDigitInterval &sig) const;
 508
 509 // Helper functions for updateFormatting
 510 void updateFormattingUsesCurrency(int32_t &changedFormattingFields);
 511 void updateFormattingPluralRules(
 512         int32_t &changedFormattingFields, UErrorCode &status);
 513 void updateFormattingAffixParser(int32_t &changedFormattingFields);
 514 void updateFormattingCurrencyAffixInfo(
 515         int32_t &changedFormattingFields,
 516         UBool updatePrecisionBasedOnCurrency,
 517         UErrorCode &status);
 518 void updateFormattingFixedPointFormatter(
 519         int32_t &changedFormattingFields);
 520 void updateFormattingLocalizedPositivePrefix(
 521         int32_t &changedFormattingFields, UErrorCode &status);
 522 void updateFormattingLocalizedPositiveSuffix(
 523         int32_t &changedFormattingFields, UErrorCode &status);
 524 void updateFormattingLocalizedNegativePrefix(
 525         int32_t &changedFormattingFields, UErrorCode &status);
 526 void updateFormattingLocalizedNegativeSuffix(
 527         int32_t &changedFormattingFields, UErrorCode &status);
 528
 529 int32_t computeExponentPatternLength() const;
 530 int32_t countFractionDigitAndDecimalPatternLength(int32_t fracDigitCount) const;
 531 UnicodeString &toNumberPattern(
 532         UBool hasPadding, int32_t minimumLength, UnicodeString& result) const;
 533
 534 int32_t getOldFormatWidth() const;
 535 const UnicodeString &getConstSymbol(
 536         DecimalFormatSymbols::ENumberFormatSymbol symbol) const;
 537 UBool isParseFastpath() const;
 538
 539 friend class DecimalFormat;
 540
 541 };
 542
 543
 544 U_NAMESPACE_END
 545 #endif /* #if !UCONFIG_NO_FORMATTING */
 546 #endif // DECIMFMTIMPL_H
 547 //eof