/* ******************************************************************************** * 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 UBool maybeFormatWithDigitList( T number, UnicodeString &appendTo, FieldPositionHandler &handler, UErrorCode &status) const; template 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