ICU 56 update step 1

source/i18n/decimfmtimpl.h

+/*
+********************************************************************************
+*   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