| /* |
| ******************************************************************************** |
| * Copyright (C) 2015, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ******************************************************************************** |
| * |
| * File decimfmtimpl.h |
| ******************************************************************************** |
| */ |
| |
| #ifndef DECIMFMTIMPL_H |
| #define DECIMFMTIMPL_H |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| #include "unicode/decimfmt.h" |
| #include "unicode/uobject.h" |
| #include "affixpatternparser.h" |
| #include "digitaffixesandpadding.h" |
| #include "digitformatter.h" |
| #include "digitgrouping.h" |
| #include "precision.h" |
| |
| U_NAMESPACE_BEGIN |
| |
| class UnicodeString; |
| class FieldPosition; |
| class ValueFormatter; |
| class FieldPositionHandler; |
| class FixedDecimal; |
| |
| /** |
| * DecimalFormatImpl is the glue code between the legacy DecimalFormat class |
| * and the new decimal formatting classes. DecimalFormat still handles |
| * parsing directly. However, DecimalFormat uses attributes of this class |
| * for parsing when possible. |
| * |
| * The public API of this class closely mirrors the legacy API of the |
| * legacy DecimalFormat deviating only when the legacy API does not make |
| * sense. For example, although DecimalFormat has a |
| * getPadCharacterString() method, DecimalFormatImpl has a getPadCharacter() |
| * method because formatting uses only a single pad character for padding. |
| * |
| * Each legacy DecimalFormat instance heap allocates its own instance of |
| * this class. Most DecimalFormat methods that deal with formatting simply |
| * delegate to the DecimalFormat's DecimalFormatImpl method. |
| * |
| * Because DecimalFormat extends NumberFormat, Each instance of this class |
| * "borrows" a pointer to the NumberFormat part of its enclosing DecimalFormat |
| * instance. This way each DecimalFormatImpl instance can read or even modify |
| * the NumberFormat portion of its enclosing DecimalFormat instance. |
| * |
| * Directed acyclic graph (DAG): |
| * |
| * This class can be represented as a directed acyclic graph (DAG) where each |
| * vertex is an attribute, and each directed edge indicates that the value |
| * of the destination attribute is calculated from the value of the source |
| * attribute. Attributes with setter methods reside at the bottom of the |
| * DAG. That is, no edges point to them. We call these independent attributes |
| * because their values can be set independently of one another. The rest of |
| * the attributes are derived attributes because their values depend on the |
| * independent attributes. DecimalFormatImpl often uses the derived |
| * attributes, not the independent attributes, when formatting numbers. |
| * |
| * The independent attributes at the bottom of the DAG correspond to the legacy |
| * attributes of DecimalFormat while the attributes at the top of the DAG |
| * correspond to the attributes of the new code. The edges of the DAG |
| * correspond to the code that handles the complex interaction among all the |
| * legacy attributes of the DecimalFormat API. |
| * |
| * We use a DAG for three reasons. |
| * |
| * First, the DAG preserves backward compatibility. Clients of the legacy |
| * DecimalFormat expect existing getters and setters of each attribute to be |
| * consistent. That means if a client sets a particular attribute to a new |
| * value, the attribute should retain that value until the client sets it to |
| * a new value. The DAG allows these attributes to remain consistent even |
| * though the new code may not use them when formatting. |
| * |
| * Second, the DAG obviates the need to recalculate derived attributes with |
| * each format. Instead, the DAG "remembers" the values of all derived |
| * attributes. Only setting an independent attribute requires a recalculation. |
| * Moreover, setting an independent attribute recalculates only the affected |
| * dependent attributes rather than all dependent attributes. |
| * |
| * Third, the DAG abstracts away the complex interaction among the legacy |
| * attributes of the DecimalFormat API. |
| * |
| * Only the independent attributes of the DAG have setters and getters. |
| * Derived attributes have no setters (and often no getters either). |
| * |
| * Copy and assign: |
| * |
| * For copy and assign, DecimalFormatImpl copies and assigns every attribute |
| * regardless of whether or not it is independent. We do this for simplicity. |
| * |
| * Implementation of the DAG: |
| * |
| * The DAG consists of three smaller DAGs: |
| * 1. Grouping attributes |
| * 2. Precision attributes |
| * 3. Formatting attributes. |
| * |
| * The first two DAGs are simple in that setting any independent attribute |
| * in the DAG recalculates all the dependent attributes in that DAG. |
| * The updateGrouping() and updatePrecision() perform the respective |
| * recalculations. |
| * |
| * Because some of the derived formatting attributes are expensive to |
| * calculate, the formatting attributes DAG is more complex. The |
| * updateFormatting() method is composed of many updateFormattingXXX() |
| * methods, each of which recalculates a single derived attribute. The |
| * updateFormatting() method accepts a bitfield of recently changed |
| * attributes and passes this bitfield by reference to each of the |
| * updateFormattingXXX() methods. Each updateFormattingXXX() method checks |
| * the bitfield to see if any of the attributes it uses to compute the XXX |
| * attribute changed. If none of them changed, it exists immediately. However, |
| * if at least one of them changed, it recalculates the XXX attribute and |
| * sets the corresponding bit in the bitfield. In this way, each |
| * updateFormattingXXX() method encodes the directed edges in the formatting |
| * DAG that point to the attribute its calculating. |
| * |
| * Maintenance of the updateFormatting() method. |
| * |
| * Use care when changing the updateFormatting() method. |
| * The updateFormatting() method must call each updateFormattingXXX() in the |
| * same partial order that the formatting DAG prescribes. That is, the |
| * attributes near the bottom of the DAG must be calculated before attributes |
| * further up. As we mentioned in the prvious paragraph, the directed edges of |
| * the formatting DAG are encoded within each updateFormattingXXX() method. |
| * Finally, adding new attributes may involve adding to the bitmap that the |
| * updateFormatting() method uses. The top most attributes in the DAG, |
| * those that do not point to any attributes but only have attributes |
| * pointing to it, need not have a slot in the bitmap. |
| * |
| * Keep in mind that most of the code that makes the legacy DecimalFormat API |
| * work the way it always has before can be found in these various updateXXX() |
| * methods. For example the updatePrecisionForScientific() method |
| * handles the complex interactions amoung the various precision attributes |
| * when formatting in scientific notation. Changing the way attributes |
| * interract, often means changing one of these updateXXX() methods. |
| * |
| * Conclusion: |
| * |
| * The DecimFmtImpl class is the glue code between the legacy and new |
| * number formatting code. It uses a direct acyclic graph (DAG) to |
| * maintain backward compatibility, to make the code efficient, and to |
| * abstract away the complex interraction among legacy attributs. |
| */ |
| |
| |
| class DecimalFormatImpl : public UObject { |
| public: |
| |
| DecimalFormatImpl( |
| NumberFormat *super, |
| const Locale &locale, |
| const UnicodeString &pattern, |
| UErrorCode &status); |
| DecimalFormatImpl( |
| NumberFormat *super, |
| const UnicodeString &pattern, |
| DecimalFormatSymbols *symbolsToAdopt, |
| UParseError &parseError, |
| UErrorCode &status); |
| DecimalFormatImpl( |
| NumberFormat *super, |
| const DecimalFormatImpl &other, |
| UErrorCode &status); |
| DecimalFormatImpl &assign( |
| const DecimalFormatImpl &other, UErrorCode &status); |
| virtual ~DecimalFormatImpl(); |
| void adoptDecimalFormatSymbols(DecimalFormatSymbols *symbolsToAdopt); |
| const DecimalFormatSymbols &getDecimalFormatSymbols() const { |
| return *fSymbols; |
| } |
| UnicodeString &format( |
| int32_t number, |
| UnicodeString &appendTo, |
| FieldPosition &pos, |
| UErrorCode &status) const; |
| UnicodeString &format( |
| int32_t number, |
| UnicodeString &appendTo, |
| FieldPositionIterator *posIter, |
| UErrorCode &status) const; |
| UnicodeString &format( |
| int64_t number, |
| UnicodeString &appendTo, |
| FieldPosition &pos, |
| UErrorCode &status) const; |
| UnicodeString &format( |
| double number, |
| UnicodeString &appendTo, |
| FieldPosition &pos, |
| UErrorCode &status) const; |
| UnicodeString &format( |
| const DigitList &number, |
| UnicodeString &appendTo, |
| FieldPosition &pos, |
| UErrorCode &status) const; |
| UnicodeString &format( |
| int64_t number, |
| UnicodeString &appendTo, |
| FieldPositionIterator *posIter, |
| UErrorCode &status) const; |
| UnicodeString &format( |
| double number, |
| UnicodeString &appendTo, |
| FieldPositionIterator *posIter, |
| UErrorCode &status) const; |
| UnicodeString &format( |
| const DigitList &number, |
| UnicodeString &appendTo, |
| FieldPositionIterator *posIter, |
| UErrorCode &status) const; |
| UnicodeString &format( |
| const StringPiece &number, |
| UnicodeString &appendTo, |
| FieldPositionIterator *posIter, |
| UErrorCode &status) const; |
| UnicodeString &format( |
| const VisibleDigitsWithExponent &digits, |
| UnicodeString &appendTo, |
| FieldPosition &pos, |
| UErrorCode &status) const; |
| UnicodeString &format( |
| const VisibleDigitsWithExponent &digits, |
| UnicodeString &appendTo, |
| FieldPositionIterator *posIter, |
| UErrorCode &status) const; |
| |
| UBool operator==(const DecimalFormatImpl &) const; |
| |
| UBool operator!=(const DecimalFormatImpl &other) const { |
| return !(*this == other); |
| } |
| |
| void setRoundingMode(DecimalFormat::ERoundingMode mode) { |
| fRoundingMode = mode; |
| fEffPrecision.fMantissa.fExactOnly = (fRoundingMode == DecimalFormat::kRoundUnnecessary); |
| fEffPrecision.fMantissa.fRoundingMode = mode; |
| } |
| DecimalFormat::ERoundingMode getRoundingMode() const { |
| return fRoundingMode; |
| } |
| void setFailIfMoreThanMaxDigits(UBool b) { |
| fEffPrecision.fMantissa.fFailIfOverMax = b; |
| } |
| UBool isFailIfMoreThanMaxDigits() const { return fEffPrecision.fMantissa.fFailIfOverMax; } |
| void setMinimumSignificantDigits(int32_t newValue); |
| void setMaximumSignificantDigits(int32_t newValue); |
| void setMinMaxSignificantDigits(int32_t min, int32_t max); |
| void setScientificNotation(UBool newValue); |
| void setSignificantDigitsUsed(UBool newValue); |
| |
| int32_t getMinimumSignificantDigits() const { |
| return fMinSigDigits; } |
| int32_t getMaximumSignificantDigits() const { |
| return fMaxSigDigits; } |
| UBool isScientificNotation() const { return fUseScientific; } |
| UBool areSignificantDigitsUsed() const { return fUseSigDigits; } |
| void setGroupingSize(int32_t newValue); |
| void setSecondaryGroupingSize(int32_t newValue); |
| void setMinimumGroupingDigits(int32_t newValue); |
| int32_t getGroupingSize() const { return fGrouping.fGrouping; } |
| int32_t getSecondaryGroupingSize() const { return fGrouping.fGrouping2; } |
| int32_t getMinimumGroupingDigits() const { return fGrouping.fMinGrouping; } |
| void applyPattern(const UnicodeString &pattern, UErrorCode &status); |
| void applyPatternFavorCurrencyPrecision( |
| const UnicodeString &pattern, UErrorCode &status); |
| void applyPattern( |
| const UnicodeString &pattern, UParseError &perror, UErrorCode &status); |
| void applyLocalizedPattern(const UnicodeString &pattern, UErrorCode &status); |
| void applyLocalizedPattern( |
| const UnicodeString &pattern, UParseError &perror, UErrorCode &status); |
| void setCurrencyUsage(UCurrencyUsage usage, UErrorCode &status); |
| UCurrencyUsage getCurrencyUsage() const { return fCurrencyUsage; } |
| void setRoundingIncrement(double d); |
| double getRoundingIncrement() const; |
| int32_t getMultiplier() const; |
| void setMultiplier(int32_t m); |
| UChar32 getPadCharacter() const { return fAffixes.fPadChar; } |
| void setPadCharacter(UChar32 c) { fAffixes.fPadChar = c; } |
| int32_t getFormatWidth() const { return fAffixes.fWidth; } |
| void setFormatWidth(int32_t x) { fAffixes.fWidth = x; } |
| DigitAffixesAndPadding::EPadPosition getPadPosition() const { |
| return fAffixes.fPadPosition; |
| } |
| void setPadPosition(DigitAffixesAndPadding::EPadPosition x) { |
| fAffixes.fPadPosition = x; |
| } |
| int32_t getMinimumExponentDigits() const { |
| return fEffPrecision.fMinExponentDigits; |
| } |
| void setMinimumExponentDigits(int32_t x) { |
| fEffPrecision.fMinExponentDigits = x; |
| } |
| UBool isExponentSignAlwaysShown() const { |
| return fOptions.fExponent.fAlwaysShowSign; |
| } |
| void setExponentSignAlwaysShown(UBool x) { |
| fOptions.fExponent.fAlwaysShowSign = x; |
| } |
| UBool isDecimalSeparatorAlwaysShown() const { |
| return fOptions.fMantissa.fAlwaysShowDecimal; |
| } |
| void setDecimalSeparatorAlwaysShown(UBool x) { |
| fOptions.fMantissa.fAlwaysShowDecimal = x; |
| } |
| UnicodeString &getPositivePrefix(UnicodeString &result) const; |
| UnicodeString &getPositiveSuffix(UnicodeString &result) const; |
| UnicodeString &getNegativePrefix(UnicodeString &result) const; |
| UnicodeString &getNegativeSuffix(UnicodeString &result) const; |
| void setPositivePrefix(const UnicodeString &str); |
| void setPositiveSuffix(const UnicodeString &str); |
| void setNegativePrefix(const UnicodeString &str); |
| void setNegativeSuffix(const UnicodeString &str); |
| UnicodeString &toPattern(UnicodeString& result) const; |
| FixedDecimal &getFixedDecimal(double value, FixedDecimal &result, UErrorCode &status) const; |
| FixedDecimal &getFixedDecimal(DigitList &number, FixedDecimal &result, UErrorCode &status) const; |
| DigitList &round(DigitList &number, UErrorCode &status) const; |
| |
| VisibleDigitsWithExponent & |
| initVisibleDigitsWithExponent( |
| int64_t number, |
| VisibleDigitsWithExponent &digits, |
| UErrorCode &status) const; |
| VisibleDigitsWithExponent & |
| initVisibleDigitsWithExponent( |
| double number, |
| VisibleDigitsWithExponent &digits, |
| UErrorCode &status) const; |
| VisibleDigitsWithExponent & |
| initVisibleDigitsWithExponent( |
| DigitList &number, |
| VisibleDigitsWithExponent &digits, |
| UErrorCode &status) const; |
| |
| void updatePrecision(); |
| void updateGrouping(); |
| void updateCurrency(UErrorCode &status); |
| |
| |
| private: |
| // Disallow copy and assign |
| DecimalFormatImpl(const DecimalFormatImpl &other); |
| DecimalFormatImpl &operator=(const DecimalFormatImpl &other); |
| NumberFormat *fSuper; |
| DigitList fMultiplier; |
| int32_t fScale; |
| |
| DecimalFormat::ERoundingMode fRoundingMode; |
| |
| // These fields include what the user can see and set. |
| // When the user updates these fields, it triggers automatic updates of |
| // other fields that may be invisible to user |
| |
| // Updating any of the following fields triggers an update to |
| // fEffPrecision.fMantissa.fMin, |
| // fEffPrecision.fMantissa.fMax, |
| // fEffPrecision.fMantissa.fSignificant fields |
| // We have this two phase update because of backward compatibility. |
| // DecimalFormat has to remember all settings even if those settings are |
| // invalid or disabled. |
| int32_t fMinSigDigits; |
| int32_t fMaxSigDigits; |
| UBool fUseScientific; |
| UBool fUseSigDigits; |
| // In addition to these listed above, changes to min/max int digits and |
| // min/max frac digits from fSuper also trigger an update. |
| |
| // Updating any of the following fields triggers an update to |
| // fEffGrouping field Again we do it this way because original |
| // grouping settings have to be retained if grouping is turned off. |
| DigitGrouping fGrouping; |
| // In addition to these listed above, changes to isGroupingUsed in |
| // fSuper also triggers an update to fEffGrouping. |
| |
| // Updating any of the following fields triggers updates on the following: |
| // fMonetary, fRules, fAffixParser, fCurrencyAffixInfo, |
| // fFormatter, fAffixes.fPositivePrefiix, fAffixes.fPositiveSuffix, |
| // fAffixes.fNegativePrefiix, fAffixes.fNegativeSuffix |
| // We do this two phase update because localizing the affix patterns |
| // and formatters can be expensive. Better to do it once with the setters |
| // than each time within format. |
| AffixPattern fPositivePrefixPattern; |
| AffixPattern fNegativePrefixPattern; |
| AffixPattern fPositiveSuffixPattern; |
| AffixPattern fNegativeSuffixPattern; |
| DecimalFormatSymbols *fSymbols; |
| UCurrencyUsage fCurrencyUsage; |
| // In addition to these listed above, changes to getCurrency() in |
| // fSuper also triggers an update. |
| |
| // Optional may be NULL |
| PluralRules *fRules; |
| |
| // These fields are totally hidden from user and are used to derive the affixes |
| // in fAffixes below from the four affix patterns above. |
| UBool fMonetary; |
| AffixPatternParser fAffixParser; |
| CurrencyAffixInfo fCurrencyAffixInfo; |
| |
| // The actual precision used when formatting |
| ScientificPrecision fEffPrecision; |
| |
| // The actual grouping used when formatting |
| DigitGrouping fEffGrouping; |
| SciFormatterOptions fOptions; // Encapsulates fixed precision options |
| DigitFormatter fFormatter; |
| DigitAffixesAndPadding fAffixes; |
| |
| UnicodeString &formatInt32( |
| int32_t number, |
| UnicodeString &appendTo, |
| FieldPositionHandler &handler, |
| UErrorCode &status) const; |
| |
| UnicodeString &formatInt64( |
| int64_t number, |
| UnicodeString &appendTo, |
| FieldPositionHandler &handler, |
| UErrorCode &status) const; |
| |
| UnicodeString &formatDouble( |
| double number, |
| UnicodeString &appendTo, |
| FieldPositionHandler &handler, |
| UErrorCode &status) const; |
| |
| // Scales for precent or permille symbols |
| UnicodeString &formatDigitList( |
| DigitList &number, |
| UnicodeString &appendTo, |
| FieldPositionHandler &handler, |
| UErrorCode &status) const; |
| |
| // Does not scale for precent or permille symbols |
| UnicodeString &formatAdjustedDigitList( |
| DigitList &number, |
| UnicodeString &appendTo, |
| FieldPositionHandler &handler, |
| UErrorCode &status) const; |
| |
| UnicodeString &formatVisibleDigitsWithExponent( |
| const VisibleDigitsWithExponent &number, |
| UnicodeString &appendTo, |
| FieldPositionHandler &handler, |
| UErrorCode &status) const; |
| |
| VisibleDigitsWithExponent & |
| initVisibleDigitsFromAdjusted( |
| DigitList &number, |
| VisibleDigitsWithExponent &digits, |
| UErrorCode &status) const; |
| |
| template<class T> |
| UBool maybeFormatWithDigitList( |
| T number, |
| UnicodeString &appendTo, |
| FieldPositionHandler &handler, |
| UErrorCode &status) const; |
| |
| template<class T> |
| UBool maybeInitVisibleDigitsFromDigitList( |
| T number, |
| VisibleDigitsWithExponent &digits, |
| UErrorCode &status) const; |
| |
| DigitList &adjustDigitList(DigitList &number, UErrorCode &status) const; |
| |
| void applyPattern( |
| const UnicodeString &pattern, |
| UBool localized, UParseError &perror, UErrorCode &status); |
| |
| ValueFormatter &prepareValueFormatter(ValueFormatter &vf) const; |
| void setMultiplierScale(int32_t s); |
| int32_t getPatternScale() const; |
| void setScale(int32_t s) { fScale = s; } |
| int32_t getScale() const { return fScale; } |
| |
| // Updates everything |
| void updateAll(UErrorCode &status); |
| void updateAll( |
| int32_t formattingFlags, |
| UBool updatePrecisionBasedOnCurrency, |
| UErrorCode &status); |
| |
| // Updates from formatting pattern changes |
| void updateForApplyPattern(UErrorCode &status); |
| void updateForApplyPatternFavorCurrencyPrecision(UErrorCode &status); |
| |
| // Updates from changes to third group of attributes |
| void updateFormatting(int32_t changedFormattingFields, UErrorCode &status); |
| void updateFormatting( |
| int32_t changedFormattingFields, |
| UBool updatePrecisionBasedOnCurrency, |
| UErrorCode &status); |
| |
| // Helper functions for updatePrecision |
| void updatePrecisionForScientific(); |
| void updatePrecisionForFixed(); |
| void extractMinMaxDigits(DigitInterval &min, DigitInterval &max) const; |
| void extractSigDigits(SignificantDigitInterval &sig) const; |
| |
| // Helper functions for updateFormatting |
| void updateFormattingUsesCurrency(int32_t &changedFormattingFields); |
| void updateFormattingPluralRules( |
| int32_t &changedFormattingFields, UErrorCode &status); |
| void updateFormattingAffixParser(int32_t &changedFormattingFields); |
| void updateFormattingCurrencyAffixInfo( |
| int32_t &changedFormattingFields, |
| UBool updatePrecisionBasedOnCurrency, |
| UErrorCode &status); |
| void updateFormattingFixedPointFormatter( |
| int32_t &changedFormattingFields); |
| void updateFormattingLocalizedPositivePrefix( |
| int32_t &changedFormattingFields, UErrorCode &status); |
| void updateFormattingLocalizedPositiveSuffix( |
| int32_t &changedFormattingFields, UErrorCode &status); |
| void updateFormattingLocalizedNegativePrefix( |
| int32_t &changedFormattingFields, UErrorCode &status); |
| void updateFormattingLocalizedNegativeSuffix( |
| int32_t &changedFormattingFields, UErrorCode &status); |
| |
| int32_t computeExponentPatternLength() const; |
| int32_t countFractionDigitAndDecimalPatternLength(int32_t fracDigitCount) const; |
| UnicodeString &toNumberPattern( |
| UBool hasPadding, int32_t minimumLength, UnicodeString& result) const; |
| |
| int32_t getOldFormatWidth() const; |
| const UnicodeString &getConstSymbol( |
| DecimalFormatSymbols::ENumberFormatSymbol symbol) const; |
| UBool isParseFastpath() const; |
| |
| friend class DecimalFormat; |
| |
| }; |
| |
| |
| U_NAMESPACE_END |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |
| #endif // DECIMFMTIMPL_H |
| //eof |
