| /* | |
| * Copyright (C) 2015, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| * | |
| * file name: decimfmtimpl.cpp | |
| */ | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_FORMATTING | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #if !defined(STARBOARD) | |
| #include <math.h> | |
| #endif | |
| #include "unicode/numfmt.h" | |
| #include "unicode/plurrule.h" | |
| #include "unicode/ustring.h" | |
| #include "decimalformatpattern.h" | |
| #include "decimalformatpatternimpl.h" | |
| #include "decimfmtimpl.h" | |
| #include "fphdlimp.h" | |
| #include "plurrule_impl.h" | |
| #include "valueformatter.h" | |
| #include "visibledigits.h" | |
| U_NAMESPACE_BEGIN | |
| static const int32_t kMaxScientificIntegerDigits = 8; | |
| static const int32_t kFormattingPosPrefix = (1 << 0); | |
| static const int32_t kFormattingNegPrefix = (1 << 1); | |
| static const int32_t kFormattingPosSuffix = (1 << 2); | |
| static const int32_t kFormattingNegSuffix = (1 << 3); | |
| static const int32_t kFormattingSymbols = (1 << 4); | |
| static const int32_t kFormattingCurrency = (1 << 5); | |
| static const int32_t kFormattingUsesCurrency = (1 << 6); | |
| static const int32_t kFormattingPluralRules = (1 << 7); | |
| static const int32_t kFormattingAffixParser = (1 << 8); | |
| static const int32_t kFormattingCurrencyAffixInfo = (1 << 9); | |
| static const int32_t kFormattingAll = (1 << 10) - 1; | |
| static const int32_t kFormattingAffixes = | |
| kFormattingPosPrefix | kFormattingPosSuffix | | |
| kFormattingNegPrefix | kFormattingNegSuffix; | |
| static const int32_t kFormattingAffixParserWithCurrency = | |
| kFormattingAffixParser | kFormattingCurrencyAffixInfo; | |
| DecimalFormatImpl::DecimalFormatImpl( | |
| NumberFormat *super, | |
| const Locale &locale, | |
| const UnicodeString &pattern, | |
| UErrorCode &status) | |
| : fSuper(super), | |
| fScale(0), | |
| fRoundingMode(DecimalFormat::kRoundHalfEven), | |
| fSymbols(NULL), | |
| fCurrencyUsage(UCURR_USAGE_STANDARD), | |
| fRules(NULL), | |
| fMonetary(FALSE) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| fSymbols = new DecimalFormatSymbols( | |
| locale, status); | |
| if (fSymbols == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| UParseError parseError; | |
| applyPattern(pattern, FALSE, parseError, status); | |
| updateAll(status); | |
| } | |
| DecimalFormatImpl::DecimalFormatImpl( | |
| NumberFormat *super, | |
| const UnicodeString &pattern, | |
| DecimalFormatSymbols *symbolsToAdopt, | |
| UParseError &parseError, | |
| UErrorCode &status) | |
| : fSuper(super), | |
| fScale(0), | |
| fRoundingMode(DecimalFormat::kRoundHalfEven), | |
| fSymbols(symbolsToAdopt), | |
| fCurrencyUsage(UCURR_USAGE_STANDARD), | |
| fRules(NULL), | |
| fMonetary(FALSE) { | |
| applyPattern(pattern, FALSE, parseError, status); | |
| updateAll(status); | |
| } | |
| DecimalFormatImpl::DecimalFormatImpl( | |
| NumberFormat *super, const DecimalFormatImpl &other, UErrorCode &status) : | |
| fSuper(super), | |
| fMultiplier(other.fMultiplier), | |
| fScale(other.fScale), | |
| fRoundingMode(other.fRoundingMode), | |
| fMinSigDigits(other.fMinSigDigits), | |
| fMaxSigDigits(other.fMaxSigDigits), | |
| fUseScientific(other.fUseScientific), | |
| fUseSigDigits(other.fUseSigDigits), | |
| fGrouping(other.fGrouping), | |
| fPositivePrefixPattern(other.fPositivePrefixPattern), | |
| fNegativePrefixPattern(other.fNegativePrefixPattern), | |
| fPositiveSuffixPattern(other.fPositiveSuffixPattern), | |
| fNegativeSuffixPattern(other.fNegativeSuffixPattern), | |
| fSymbols(other.fSymbols), | |
| fCurrencyUsage(other.fCurrencyUsage), | |
| fRules(NULL), | |
| fMonetary(other.fMonetary), | |
| fAffixParser(other.fAffixParser), | |
| fCurrencyAffixInfo(other.fCurrencyAffixInfo), | |
| fEffPrecision(other.fEffPrecision), | |
| fEffGrouping(other.fEffGrouping), | |
| fOptions(other.fOptions), | |
| fFormatter(other.fFormatter), | |
| fAffixes(other.fAffixes) { | |
| fSymbols = new DecimalFormatSymbols(*fSymbols); | |
| if (fSymbols == NULL && U_SUCCESS(status)) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| if (other.fRules != NULL) { | |
| fRules = new PluralRules(*other.fRules); | |
| if (fRules == NULL && U_SUCCESS(status)) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| } | |
| } | |
| DecimalFormatImpl & | |
| DecimalFormatImpl::assign(const DecimalFormatImpl &other, UErrorCode &status) { | |
| if (U_FAILURE(status) || this == &other) { | |
| return (*this); | |
| } | |
| UObject::operator=(other); | |
| fMultiplier = other.fMultiplier; | |
| fScale = other.fScale; | |
| fRoundingMode = other.fRoundingMode; | |
| fMinSigDigits = other.fMinSigDigits; | |
| fMaxSigDigits = other.fMaxSigDigits; | |
| fUseScientific = other.fUseScientific; | |
| fUseSigDigits = other.fUseSigDigits; | |
| fGrouping = other.fGrouping; | |
| fPositivePrefixPattern = other.fPositivePrefixPattern; | |
| fNegativePrefixPattern = other.fNegativePrefixPattern; | |
| fPositiveSuffixPattern = other.fPositiveSuffixPattern; | |
| fNegativeSuffixPattern = other.fNegativeSuffixPattern; | |
| fCurrencyUsage = other.fCurrencyUsage; | |
| fMonetary = other.fMonetary; | |
| fAffixParser = other.fAffixParser; | |
| fCurrencyAffixInfo = other.fCurrencyAffixInfo; | |
| fEffPrecision = other.fEffPrecision; | |
| fEffGrouping = other.fEffGrouping; | |
| fOptions = other.fOptions; | |
| fFormatter = other.fFormatter; | |
| fAffixes = other.fAffixes; | |
| *fSymbols = *other.fSymbols; | |
| if (fRules != NULL && other.fRules != NULL) { | |
| *fRules = *other.fRules; | |
| } else { | |
| delete fRules; | |
| fRules = other.fRules; | |
| if (fRules != NULL) { | |
| fRules = new PluralRules(*fRules); | |
| if (fRules == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return *this; | |
| } | |
| } | |
| } | |
| return *this; | |
| } | |
| UBool | |
| DecimalFormatImpl::operator==(const DecimalFormatImpl &other) const { | |
| if (this == &other) { | |
| return TRUE; | |
| } | |
| return (fMultiplier == other.fMultiplier) | |
| && (fScale == other.fScale) | |
| && (fRoundingMode == other.fRoundingMode) | |
| && (fMinSigDigits == other.fMinSigDigits) | |
| && (fMaxSigDigits == other.fMaxSigDigits) | |
| && (fUseScientific == other.fUseScientific) | |
| && (fUseSigDigits == other.fUseSigDigits) | |
| && fGrouping.equals(other.fGrouping) | |
| && fPositivePrefixPattern.equals(other.fPositivePrefixPattern) | |
| && fNegativePrefixPattern.equals(other.fNegativePrefixPattern) | |
| && fPositiveSuffixPattern.equals(other.fPositiveSuffixPattern) | |
| && fNegativeSuffixPattern.equals(other.fNegativeSuffixPattern) | |
| && fCurrencyUsage == other.fCurrencyUsage | |
| && fAffixParser.equals(other.fAffixParser) | |
| && fCurrencyAffixInfo.equals(other.fCurrencyAffixInfo) | |
| && fEffPrecision.equals(other.fEffPrecision) | |
| && fEffGrouping.equals(other.fEffGrouping) | |
| && fOptions.equals(other.fOptions) | |
| && fFormatter.equals(other.fFormatter) | |
| && fAffixes.equals(other.fAffixes) | |
| && (*fSymbols == *other.fSymbols) | |
| && ((fRules == other.fRules) || ( | |
| (fRules != NULL) && (other.fRules != NULL) | |
| && (*fRules == *other.fRules))) | |
| && (fMonetary == other.fMonetary); | |
| } | |
| DecimalFormatImpl::~DecimalFormatImpl() { | |
| delete fSymbols; | |
| delete fRules; | |
| } | |
| ValueFormatter & | |
| DecimalFormatImpl::prepareValueFormatter(ValueFormatter &vf) const { | |
| if (fUseScientific) { | |
| vf.prepareScientificFormatting( | |
| fFormatter, fEffPrecision, fOptions); | |
| return vf; | |
| } | |
| vf.prepareFixedDecimalFormatting( | |
| fFormatter, fEffGrouping, fEffPrecision.fMantissa, fOptions.fMantissa); | |
| return vf; | |
| } | |
| int32_t | |
| DecimalFormatImpl::getPatternScale() const { | |
| UBool usesPercent = fPositivePrefixPattern.usesPercent() || | |
| fPositiveSuffixPattern.usesPercent() || | |
| fNegativePrefixPattern.usesPercent() || | |
| fNegativeSuffixPattern.usesPercent(); | |
| if (usesPercent) { | |
| return 2; | |
| } | |
| UBool usesPermill = fPositivePrefixPattern.usesPermill() || | |
| fPositiveSuffixPattern.usesPermill() || | |
| fNegativePrefixPattern.usesPermill() || | |
| fNegativeSuffixPattern.usesPermill(); | |
| if (usesPermill) { | |
| return 3; | |
| } | |
| return 0; | |
| } | |
| void | |
| DecimalFormatImpl::setMultiplierScale(int32_t scale) { | |
| if (scale == 0) { | |
| // Needed to preserve equality. fMultiplier == 0 means | |
| // multiplier is 1. | |
| fMultiplier.set(0); | |
| } else { | |
| fMultiplier.set(1); | |
| fMultiplier.shiftDecimalRight(scale); | |
| } | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::format( | |
| int32_t number, | |
| UnicodeString &appendTo, | |
| FieldPosition &pos, | |
| UErrorCode &status) const { | |
| FieldPositionOnlyHandler handler(pos); | |
| return formatInt32(number, appendTo, handler, status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::format( | |
| int32_t number, | |
| UnicodeString &appendTo, | |
| FieldPositionIterator *posIter, | |
| UErrorCode &status) const { | |
| FieldPositionIteratorHandler handler(posIter, status); | |
| return formatInt32(number, appendTo, handler, status); | |
| } | |
| template<class T> | |
| UBool DecimalFormatImpl::maybeFormatWithDigitList( | |
| T number, | |
| UnicodeString &appendTo, | |
| FieldPositionHandler &handler, | |
| UErrorCode &status) const { | |
| if (!fMultiplier.isZero()) { | |
| DigitList digits; | |
| digits.set(number); | |
| digits.mult(fMultiplier, status); | |
| digits.shiftDecimalRight(fScale); | |
| formatAdjustedDigitList(digits, appendTo, handler, status); | |
| return TRUE; | |
| } | |
| if (fScale != 0) { | |
| DigitList digits; | |
| digits.set(number); | |
| digits.shiftDecimalRight(fScale); | |
| formatAdjustedDigitList(digits, appendTo, handler, status); | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| template<class T> | |
| UBool DecimalFormatImpl::maybeInitVisibleDigitsFromDigitList( | |
| T number, | |
| VisibleDigitsWithExponent &visibleDigits, | |
| UErrorCode &status) const { | |
| if (!fMultiplier.isZero()) { | |
| DigitList digits; | |
| digits.set(number); | |
| digits.mult(fMultiplier, status); | |
| digits.shiftDecimalRight(fScale); | |
| initVisibleDigitsFromAdjusted(digits, visibleDigits, status); | |
| return TRUE; | |
| } | |
| if (fScale != 0) { | |
| DigitList digits; | |
| digits.set(number); | |
| digits.shiftDecimalRight(fScale); | |
| initVisibleDigitsFromAdjusted(digits, visibleDigits, status); | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::formatInt32( | |
| int32_t number, | |
| UnicodeString &appendTo, | |
| FieldPositionHandler &handler, | |
| UErrorCode &status) const { | |
| if (maybeFormatWithDigitList(number, appendTo, handler, status)) { | |
| return appendTo; | |
| } | |
| ValueFormatter vf; | |
| return fAffixes.formatInt32( | |
| number, | |
| prepareValueFormatter(vf), | |
| handler, | |
| fRules, | |
| appendTo, | |
| status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::formatInt64( | |
| int64_t number, | |
| UnicodeString &appendTo, | |
| FieldPositionHandler &handler, | |
| UErrorCode &status) const { | |
| if (number >= INT32_MIN && number <= INT32_MAX) { | |
| return formatInt32((int32_t) number, appendTo, handler, status); | |
| } | |
| VisibleDigitsWithExponent digits; | |
| initVisibleDigitsWithExponent(number, digits, status); | |
| return formatVisibleDigitsWithExponent( | |
| digits, appendTo, handler, status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::formatDouble( | |
| double number, | |
| UnicodeString &appendTo, | |
| FieldPositionHandler &handler, | |
| UErrorCode &status) const { | |
| VisibleDigitsWithExponent digits; | |
| initVisibleDigitsWithExponent(number, digits, status); | |
| return formatVisibleDigitsWithExponent( | |
| digits, appendTo, handler, status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::format( | |
| double number, | |
| UnicodeString &appendTo, | |
| FieldPosition &pos, | |
| UErrorCode &status) const { | |
| FieldPositionOnlyHandler handler(pos); | |
| return formatDouble(number, appendTo, handler, status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::format( | |
| const DigitList &number, | |
| UnicodeString &appendTo, | |
| FieldPosition &pos, | |
| UErrorCode &status) const { | |
| DigitList dl(number); | |
| FieldPositionOnlyHandler handler(pos); | |
| return formatDigitList(dl, appendTo, handler, status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::format( | |
| int64_t number, | |
| UnicodeString &appendTo, | |
| FieldPosition &pos, | |
| UErrorCode &status) const { | |
| FieldPositionOnlyHandler handler(pos); | |
| return formatInt64(number, appendTo, handler, status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::format( | |
| int64_t number, | |
| UnicodeString &appendTo, | |
| FieldPositionIterator *posIter, | |
| UErrorCode &status) const { | |
| FieldPositionIteratorHandler handler(posIter, status); | |
| return formatInt64(number, appendTo, handler, status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::format( | |
| double number, | |
| UnicodeString &appendTo, | |
| FieldPositionIterator *posIter, | |
| UErrorCode &status) const { | |
| FieldPositionIteratorHandler handler(posIter, status); | |
| return formatDouble(number, appendTo, handler, status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::format( | |
| const DigitList &number, | |
| UnicodeString &appendTo, | |
| FieldPositionIterator *posIter, | |
| UErrorCode &status) const { | |
| DigitList dl(number); | |
| FieldPositionIteratorHandler handler(posIter, status); | |
| return formatDigitList(dl, appendTo, handler, status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::format( | |
| const StringPiece &number, | |
| UnicodeString &appendTo, | |
| FieldPositionIterator *posIter, | |
| UErrorCode &status) const { | |
| DigitList dl; | |
| dl.set(number, status); | |
| FieldPositionIteratorHandler handler(posIter, status); | |
| return formatDigitList(dl, appendTo, handler, status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::format( | |
| const VisibleDigitsWithExponent &digits, | |
| UnicodeString &appendTo, | |
| FieldPosition &pos, | |
| UErrorCode &status) const { | |
| FieldPositionOnlyHandler handler(pos); | |
| return formatVisibleDigitsWithExponent( | |
| digits, appendTo, handler, status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::format( | |
| const VisibleDigitsWithExponent &digits, | |
| UnicodeString &appendTo, | |
| FieldPositionIterator *posIter, | |
| UErrorCode &status) const { | |
| FieldPositionIteratorHandler handler(posIter, status); | |
| return formatVisibleDigitsWithExponent( | |
| digits, appendTo, handler, status); | |
| } | |
| DigitList & | |
| DecimalFormatImpl::adjustDigitList( | |
| DigitList &number, UErrorCode &status) const { | |
| number.setRoundingMode(fRoundingMode); | |
| if (!fMultiplier.isZero()) { | |
| number.mult(fMultiplier, status); | |
| } | |
| if (fScale != 0) { | |
| number.shiftDecimalRight(fScale); | |
| } | |
| number.reduce(); | |
| return number; | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::formatDigitList( | |
| DigitList &number, | |
| UnicodeString &appendTo, | |
| FieldPositionHandler &handler, | |
| UErrorCode &status) const { | |
| VisibleDigitsWithExponent digits; | |
| initVisibleDigitsWithExponent(number, digits, status); | |
| return formatVisibleDigitsWithExponent( | |
| digits, appendTo, handler, status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::formatAdjustedDigitList( | |
| DigitList &number, | |
| UnicodeString &appendTo, | |
| FieldPositionHandler &handler, | |
| UErrorCode &status) const { | |
| ValueFormatter vf; | |
| return fAffixes.format( | |
| number, | |
| prepareValueFormatter(vf), | |
| handler, | |
| fRules, | |
| appendTo, | |
| status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::formatVisibleDigitsWithExponent( | |
| const VisibleDigitsWithExponent &digits, | |
| UnicodeString &appendTo, | |
| FieldPositionHandler &handler, | |
| UErrorCode &status) const { | |
| ValueFormatter vf; | |
| return fAffixes.format( | |
| digits, | |
| prepareValueFormatter(vf), | |
| handler, | |
| fRules, | |
| appendTo, | |
| status); | |
| } | |
| static FixedDecimal &initFixedDecimal( | |
| const VisibleDigits &digits, FixedDecimal &result) { | |
| result.source = 0.0; | |
| result.isNegative = digits.isNegative(); | |
| result.isNanOrInfinity = digits.isNaNOrInfinity(); | |
| digits.getFixedDecimal( | |
| result.source, result.intValue, result.decimalDigits, | |
| result.decimalDigitsWithoutTrailingZeros, | |
| result.visibleDecimalDigitCount, result.hasIntegerValue); | |
| return result; | |
| } | |
| FixedDecimal & | |
| DecimalFormatImpl::getFixedDecimal(double number, FixedDecimal &result, UErrorCode &status) const { | |
| if (U_FAILURE(status)) { | |
| return result; | |
| } | |
| VisibleDigits digits; | |
| fEffPrecision.fMantissa.initVisibleDigits(number, digits, status); | |
| return initFixedDecimal(digits, result); | |
| } | |
| FixedDecimal & | |
| DecimalFormatImpl::getFixedDecimal( | |
| DigitList &number, FixedDecimal &result, UErrorCode &status) const { | |
| if (U_FAILURE(status)) { | |
| return result; | |
| } | |
| VisibleDigits digits; | |
| fEffPrecision.fMantissa.initVisibleDigits(number, digits, status); | |
| return initFixedDecimal(digits, result); | |
| } | |
| VisibleDigitsWithExponent & | |
| DecimalFormatImpl::initVisibleDigitsWithExponent( | |
| int64_t number, | |
| VisibleDigitsWithExponent &digits, | |
| UErrorCode &status) const { | |
| if (maybeInitVisibleDigitsFromDigitList( | |
| number, digits, status)) { | |
| return digits; | |
| } | |
| if (fUseScientific) { | |
| fEffPrecision.initVisibleDigitsWithExponent( | |
| number, digits, status); | |
| } else { | |
| fEffPrecision.fMantissa.initVisibleDigitsWithExponent( | |
| number, digits, status); | |
| } | |
| return digits; | |
| } | |
| VisibleDigitsWithExponent & | |
| DecimalFormatImpl::initVisibleDigitsWithExponent( | |
| double number, | |
| VisibleDigitsWithExponent &digits, | |
| UErrorCode &status) const { | |
| if (maybeInitVisibleDigitsFromDigitList( | |
| number, digits, status)) { | |
| return digits; | |
| } | |
| if (fUseScientific) { | |
| fEffPrecision.initVisibleDigitsWithExponent( | |
| number, digits, status); | |
| } else { | |
| fEffPrecision.fMantissa.initVisibleDigitsWithExponent( | |
| number, digits, status); | |
| } | |
| return digits; | |
| } | |
| VisibleDigitsWithExponent & | |
| DecimalFormatImpl::initVisibleDigitsWithExponent( | |
| DigitList &number, | |
| VisibleDigitsWithExponent &digits, | |
| UErrorCode &status) const { | |
| adjustDigitList(number, status); | |
| return initVisibleDigitsFromAdjusted(number, digits, status); | |
| } | |
| VisibleDigitsWithExponent & | |
| DecimalFormatImpl::initVisibleDigitsFromAdjusted( | |
| DigitList &number, | |
| VisibleDigitsWithExponent &digits, | |
| UErrorCode &status) const { | |
| if (fUseScientific) { | |
| fEffPrecision.initVisibleDigitsWithExponent( | |
| number, digits, status); | |
| } else { | |
| fEffPrecision.fMantissa.initVisibleDigitsWithExponent( | |
| number, digits, status); | |
| } | |
| return digits; | |
| } | |
| DigitList & | |
| DecimalFormatImpl::round( | |
| DigitList &number, UErrorCode &status) const { | |
| if (number.isNaN() || number.isInfinite()) { | |
| return number; | |
| } | |
| adjustDigitList(number, status); | |
| ValueFormatter vf; | |
| prepareValueFormatter(vf); | |
| return vf.round(number, status); | |
| } | |
| void | |
| DecimalFormatImpl::setMinimumSignificantDigits(int32_t newValue) { | |
| fMinSigDigits = newValue; | |
| fUseSigDigits = TRUE; // ticket 9936 | |
| updatePrecision(); | |
| } | |
| void | |
| DecimalFormatImpl::setMaximumSignificantDigits(int32_t newValue) { | |
| fMaxSigDigits = newValue; | |
| fUseSigDigits = TRUE; // ticket 9936 | |
| updatePrecision(); | |
| } | |
| void | |
| DecimalFormatImpl::setMinMaxSignificantDigits(int32_t min, int32_t max) { | |
| fMinSigDigits = min; | |
| fMaxSigDigits = max; | |
| fUseSigDigits = TRUE; // ticket 9936 | |
| updatePrecision(); | |
| } | |
| void | |
| DecimalFormatImpl::setScientificNotation(UBool newValue) { | |
| fUseScientific = newValue; | |
| updatePrecision(); | |
| } | |
| void | |
| DecimalFormatImpl::setSignificantDigitsUsed(UBool newValue) { | |
| fUseSigDigits = newValue; | |
| updatePrecision(); | |
| } | |
| void | |
| DecimalFormatImpl::setGroupingSize(int32_t newValue) { | |
| fGrouping.fGrouping = newValue; | |
| updateGrouping(); | |
| } | |
| void | |
| DecimalFormatImpl::setSecondaryGroupingSize(int32_t newValue) { | |
| fGrouping.fGrouping2 = newValue; | |
| updateGrouping(); | |
| } | |
| void | |
| DecimalFormatImpl::setMinimumGroupingDigits(int32_t newValue) { | |
| fGrouping.fMinGrouping = newValue; | |
| updateGrouping(); | |
| } | |
| void | |
| DecimalFormatImpl::setCurrencyUsage( | |
| UCurrencyUsage currencyUsage, UErrorCode &status) { | |
| fCurrencyUsage = currencyUsage; | |
| updateFormatting(kFormattingCurrency, status); | |
| } | |
| void | |
| DecimalFormatImpl::setRoundingIncrement(double d) { | |
| if (d > 0.0) { | |
| fEffPrecision.fMantissa.fRoundingIncrement.set(d); | |
| } else { | |
| fEffPrecision.fMantissa.fRoundingIncrement.set(0.0); | |
| } | |
| } | |
| double | |
| DecimalFormatImpl::getRoundingIncrement() const { | |
| return fEffPrecision.fMantissa.fRoundingIncrement.getDouble(); | |
| } | |
| int32_t | |
| DecimalFormatImpl::getMultiplier() const { | |
| if (fMultiplier.isZero()) { | |
| return 1; | |
| } | |
| return (int32_t) fMultiplier.getDouble(); | |
| } | |
| void | |
| DecimalFormatImpl::setMultiplier(int32_t m) { | |
| if (m == 0 || m == 1) { | |
| fMultiplier.set(0); | |
| } else { | |
| fMultiplier.set(m); | |
| } | |
| } | |
| void | |
| DecimalFormatImpl::setPositivePrefix(const UnicodeString &str) { | |
| fPositivePrefixPattern.remove(); | |
| fPositivePrefixPattern.addLiteral(str.getBuffer(), 0, str.length()); | |
| UErrorCode status = U_ZERO_ERROR; | |
| updateFormatting(kFormattingPosPrefix, status); | |
| } | |
| void | |
| DecimalFormatImpl::setPositiveSuffix(const UnicodeString &str) { | |
| fPositiveSuffixPattern.remove(); | |
| fPositiveSuffixPattern.addLiteral(str.getBuffer(), 0, str.length()); | |
| UErrorCode status = U_ZERO_ERROR; | |
| updateFormatting(kFormattingPosSuffix, status); | |
| } | |
| void | |
| DecimalFormatImpl::setNegativePrefix(const UnicodeString &str) { | |
| fNegativePrefixPattern.remove(); | |
| fNegativePrefixPattern.addLiteral(str.getBuffer(), 0, str.length()); | |
| UErrorCode status = U_ZERO_ERROR; | |
| updateFormatting(kFormattingNegPrefix, status); | |
| } | |
| void | |
| DecimalFormatImpl::setNegativeSuffix(const UnicodeString &str) { | |
| fNegativeSuffixPattern.remove(); | |
| fNegativeSuffixPattern.addLiteral(str.getBuffer(), 0, str.length()); | |
| UErrorCode status = U_ZERO_ERROR; | |
| updateFormatting(kFormattingNegSuffix, status); | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::getPositivePrefix(UnicodeString &result) const { | |
| result = fAffixes.fPositivePrefix.getOtherVariant().toString(); | |
| return result; | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::getPositiveSuffix(UnicodeString &result) const { | |
| result = fAffixes.fPositiveSuffix.getOtherVariant().toString(); | |
| return result; | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::getNegativePrefix(UnicodeString &result) const { | |
| result = fAffixes.fNegativePrefix.getOtherVariant().toString(); | |
| return result; | |
| } | |
| UnicodeString & | |
| DecimalFormatImpl::getNegativeSuffix(UnicodeString &result) const { | |
| result = fAffixes.fNegativeSuffix.getOtherVariant().toString(); | |
| return result; | |
| } | |
| void | |
| DecimalFormatImpl::adoptDecimalFormatSymbols(DecimalFormatSymbols *symbolsToAdopt) { | |
| if (symbolsToAdopt == NULL) { | |
| return; | |
| } | |
| delete fSymbols; | |
| fSymbols = symbolsToAdopt; | |
| UErrorCode status = U_ZERO_ERROR; | |
| updateFormatting(kFormattingSymbols, status); | |
| } | |
| void | |
| DecimalFormatImpl::applyPatternFavorCurrencyPrecision( | |
| const UnicodeString &pattern, UErrorCode &status) { | |
| UParseError perror; | |
| applyPattern(pattern, FALSE, perror, status); | |
| updateForApplyPatternFavorCurrencyPrecision(status); | |
| } | |
| void | |
| DecimalFormatImpl::applyPattern( | |
| const UnicodeString &pattern, UErrorCode &status) { | |
| UParseError perror; | |
| applyPattern(pattern, FALSE, perror, status); | |
| updateForApplyPattern(status); | |
| } | |
| void | |
| DecimalFormatImpl::applyPattern( | |
| const UnicodeString &pattern, | |
| UParseError &perror, UErrorCode &status) { | |
| applyPattern(pattern, FALSE, perror, status); | |
| updateForApplyPattern(status); | |
| } | |
| void | |
| DecimalFormatImpl::applyLocalizedPattern( | |
| const UnicodeString &pattern, UErrorCode &status) { | |
| UParseError perror; | |
| applyPattern(pattern, TRUE, perror, status); | |
| updateForApplyPattern(status); | |
| } | |
| void | |
| DecimalFormatImpl::applyLocalizedPattern( | |
| const UnicodeString &pattern, | |
| UParseError &perror, UErrorCode &status) { | |
| applyPattern(pattern, TRUE, perror, status); | |
| updateForApplyPattern(status); | |
| } | |
| void | |
| DecimalFormatImpl::applyPattern( | |
| const UnicodeString &pattern, | |
| UBool localized, UParseError &perror, UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| DecimalFormatPatternParser patternParser; | |
| if (localized) { | |
| patternParser.useSymbols(*fSymbols); | |
| } | |
| DecimalFormatPattern out; | |
| patternParser.applyPatternWithoutExpandAffix( | |
| pattern, out, perror, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| fUseScientific = out.fUseExponentialNotation; | |
| fUseSigDigits = out.fUseSignificantDigits; | |
| fSuper->NumberFormat::setMinimumIntegerDigits(out.fMinimumIntegerDigits); | |
| fSuper->NumberFormat::setMaximumIntegerDigits(out.fMaximumIntegerDigits); | |
| fSuper->NumberFormat::setMinimumFractionDigits(out.fMinimumFractionDigits); | |
| fSuper->NumberFormat::setMaximumFractionDigits(out.fMaximumFractionDigits); | |
| fMinSigDigits = out.fMinimumSignificantDigits; | |
| fMaxSigDigits = out.fMaximumSignificantDigits; | |
| fEffPrecision.fMinExponentDigits = out.fMinExponentDigits; | |
| fOptions.fExponent.fAlwaysShowSign = out.fExponentSignAlwaysShown; | |
| fSuper->NumberFormat::setGroupingUsed(out.fGroupingUsed); | |
| fGrouping.fGrouping = out.fGroupingSize; | |
| fGrouping.fGrouping2 = out.fGroupingSize2; | |
| fOptions.fMantissa.fAlwaysShowDecimal = out.fDecimalSeparatorAlwaysShown; | |
| if (out.fRoundingIncrementUsed) { | |
| fEffPrecision.fMantissa.fRoundingIncrement = out.fRoundingIncrement; | |
| } else { | |
| fEffPrecision.fMantissa.fRoundingIncrement.clear(); | |
| } | |
| fAffixes.fPadChar = out.fPad; | |
| fNegativePrefixPattern = out.fNegPrefixAffix; | |
| fNegativeSuffixPattern = out.fNegSuffixAffix; | |
| fPositivePrefixPattern = out.fPosPrefixAffix; | |
| fPositiveSuffixPattern = out.fPosSuffixAffix; | |
| // Work around. Pattern parsing code and DecimalFormat code don't agree | |
| // on the definition of field width, so we have to translate from | |
| // pattern field width to decimal format field width here. | |
| fAffixes.fWidth = out.fFormatWidth == 0 ? 0 : | |
| out.fFormatWidth + fPositivePrefixPattern.countChar32() | |
| + fPositiveSuffixPattern.countChar32(); | |
| switch (out.fPadPosition) { | |
| case DecimalFormatPattern::kPadBeforePrefix: | |
| fAffixes.fPadPosition = DigitAffixesAndPadding::kPadBeforePrefix; | |
| break; | |
| case DecimalFormatPattern::kPadAfterPrefix: | |
| fAffixes.fPadPosition = DigitAffixesAndPadding::kPadAfterPrefix; | |
| break; | |
| case DecimalFormatPattern::kPadBeforeSuffix: | |
| fAffixes.fPadPosition = DigitAffixesAndPadding::kPadBeforeSuffix; | |
| break; | |
| case DecimalFormatPattern::kPadAfterSuffix: | |
| fAffixes.fPadPosition = DigitAffixesAndPadding::kPadAfterSuffix; | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| void | |
| DecimalFormatImpl::updatePrecision() { | |
| if (fUseScientific) { | |
| updatePrecisionForScientific(); | |
| } else { | |
| updatePrecisionForFixed(); | |
| } | |
| } | |
| static void updatePrecisionForScientificMinMax( | |
| const DigitInterval &min, | |
| const DigitInterval &max, | |
| DigitInterval &resultMin, | |
| DigitInterval &resultMax, | |
| SignificantDigitInterval &resultSignificant) { | |
| resultMin.setIntDigitCount(0); | |
| resultMin.setFracDigitCount(0); | |
| resultSignificant.clear(); | |
| resultMax.clear(); | |
| int32_t maxIntDigitCount = max.getIntDigitCount(); | |
| int32_t minIntDigitCount = min.getIntDigitCount(); | |
| int32_t maxFracDigitCount = max.getFracDigitCount(); | |
| int32_t minFracDigitCount = min.getFracDigitCount(); | |
| // Not in spec: maxIntDigitCount > 8 assume | |
| // maxIntDigitCount = minIntDigitCount. Current DecimalFormat API has | |
| // no provision for unsetting maxIntDigitCount which would be useful for | |
| // scientific notation. The best we can do is assume that if | |
| // maxIntDigitCount is the default of 2000000000 or is "big enough" then | |
| // user did not intend to explicitly set it. The 8 was derived emperically | |
| // by extensive testing of legacy code. | |
| if (maxIntDigitCount > 8) { | |
| maxIntDigitCount = minIntDigitCount; | |
| } | |
| // Per the spec, exponent grouping happens if maxIntDigitCount is more | |
| // than 1 and more than minIntDigitCount. | |
| UBool bExponentGrouping = maxIntDigitCount > 1 && minIntDigitCount < maxIntDigitCount; | |
| if (bExponentGrouping) { | |
| resultMax.setIntDigitCount(maxIntDigitCount); | |
| // For exponent grouping minIntDigits is always treated as 1 even | |
| // if it wasn't set to 1! | |
| resultMin.setIntDigitCount(1); | |
| } else { | |
| // Fixed digit count left of decimal. minIntDigitCount doesn't have | |
| // to equal maxIntDigitCount i.e minIntDigitCount == 0 while | |
| // maxIntDigitCount == 1. | |
| int32_t fixedIntDigitCount = maxIntDigitCount; | |
| // If fixedIntDigitCount is 0 but | |
| // min or max fraction count is 0 too then use 1. This way we can get | |
| // unlimited precision for X.XXXEX | |
| if (fixedIntDigitCount == 0 && (minFracDigitCount == 0 || maxFracDigitCount == 0)) { | |
| fixedIntDigitCount = 1; | |
| } | |
| resultMax.setIntDigitCount(fixedIntDigitCount); | |
| resultMin.setIntDigitCount(fixedIntDigitCount); | |
| } | |
| // Spec says this is how we compute significant digits. 0 means | |
| // unlimited significant digits. | |
| int32_t maxSigDigits = minIntDigitCount + maxFracDigitCount; | |
| if (maxSigDigits > 0) { | |
| int32_t minSigDigits = minIntDigitCount + minFracDigitCount; | |
| resultSignificant.setMin(minSigDigits); | |
| resultSignificant.setMax(maxSigDigits); | |
| } | |
| } | |
| void | |
| DecimalFormatImpl::updatePrecisionForScientific() { | |
| FixedPrecision *result = &fEffPrecision.fMantissa; | |
| if (fUseSigDigits) { | |
| result->fMax.setFracDigitCount(-1); | |
| result->fMax.setIntDigitCount(1); | |
| result->fMin.setFracDigitCount(0); | |
| result->fMin.setIntDigitCount(1); | |
| result->fSignificant.clear(); | |
| extractSigDigits(result->fSignificant); | |
| return; | |
| } | |
| DigitInterval max; | |
| DigitInterval min; | |
| extractMinMaxDigits(min, max); | |
| updatePrecisionForScientificMinMax( | |
| min, max, | |
| result->fMin, result->fMax, result->fSignificant); | |
| } | |
| void | |
| DecimalFormatImpl::updatePrecisionForFixed() { | |
| FixedPrecision *result = &fEffPrecision.fMantissa; | |
| if (!fUseSigDigits) { | |
| extractMinMaxDigits(result->fMin, result->fMax); | |
| result->fSignificant.clear(); | |
| } else { | |
| extractSigDigits(result->fSignificant); | |
| result->fMin.setIntDigitCount(1); | |
| result->fMin.setFracDigitCount(0); | |
| result->fMax.clear(); | |
| } | |
| } | |
| void | |
| DecimalFormatImpl::extractMinMaxDigits( | |
| DigitInterval &min, DigitInterval &max) const { | |
| min.setIntDigitCount(fSuper->getMinimumIntegerDigits()); | |
| max.setIntDigitCount(fSuper->getMaximumIntegerDigits()); | |
| min.setFracDigitCount(fSuper->getMinimumFractionDigits()); | |
| max.setFracDigitCount(fSuper->getMaximumFractionDigits()); | |
| } | |
| void | |
| DecimalFormatImpl::extractSigDigits( | |
| SignificantDigitInterval &sig) const { | |
| sig.setMin(fMinSigDigits < 0 ? 0 : fMinSigDigits); | |
| sig.setMax(fMaxSigDigits < 0 ? 0 : fMaxSigDigits); | |
| } | |
| void | |
| DecimalFormatImpl::updateGrouping() { | |
| if (fSuper->isGroupingUsed()) { | |
| fEffGrouping = fGrouping; | |
| } else { | |
| fEffGrouping.clear(); | |
| } | |
| } | |
| void | |
| DecimalFormatImpl::updateCurrency(UErrorCode &status) { | |
| updateFormatting(kFormattingCurrency, TRUE, status); | |
| } | |
| void | |
| DecimalFormatImpl::updateFormatting( | |
| int32_t changedFormattingFields, | |
| UErrorCode &status) { | |
| updateFormatting(changedFormattingFields, TRUE, status); | |
| } | |
| void | |
| DecimalFormatImpl::updateFormatting( | |
| int32_t changedFormattingFields, | |
| UBool updatePrecisionBasedOnCurrency, | |
| UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| // Each function updates one field. Order matters. For instance, | |
| // updatePluralRules comes before updateCurrencyAffixInfo because the | |
| // fRules field is needed to update the fCurrencyAffixInfo field. | |
| updateFormattingUsesCurrency(changedFormattingFields); | |
| updateFormattingFixedPointFormatter(changedFormattingFields); | |
| updateFormattingAffixParser(changedFormattingFields); | |
| updateFormattingPluralRules(changedFormattingFields, status); | |
| updateFormattingCurrencyAffixInfo( | |
| changedFormattingFields, | |
| updatePrecisionBasedOnCurrency, | |
| status); | |
| updateFormattingLocalizedPositivePrefix( | |
| changedFormattingFields, status); | |
| updateFormattingLocalizedPositiveSuffix( | |
| changedFormattingFields, status); | |
| updateFormattingLocalizedNegativePrefix( | |
| changedFormattingFields, status); | |
| updateFormattingLocalizedNegativeSuffix( | |
| changedFormattingFields, status); | |
| } | |
| void | |
| DecimalFormatImpl::updateFormattingUsesCurrency( | |
| int32_t &changedFormattingFields) { | |
| if ((changedFormattingFields & kFormattingAffixes) == 0) { | |
| // If no affixes changed, don't need to do any work | |
| return; | |
| } | |
| UBool newUsesCurrency = | |
| fPositivePrefixPattern.usesCurrency() || | |
| fPositiveSuffixPattern.usesCurrency() || | |
| fNegativePrefixPattern.usesCurrency() || | |
| fNegativeSuffixPattern.usesCurrency(); | |
| if (fMonetary != newUsesCurrency) { | |
| fMonetary = newUsesCurrency; | |
| changedFormattingFields |= kFormattingUsesCurrency; | |
| } | |
| } | |
| void | |
| DecimalFormatImpl::updateFormattingPluralRules( | |
| int32_t &changedFormattingFields, UErrorCode &status) { | |
| if ((changedFormattingFields & (kFormattingSymbols | kFormattingUsesCurrency)) == 0) { | |
| // No work to do if both fSymbols and fMonetary | |
| // fields are unchanged | |
| return; | |
| } | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| PluralRules *newRules = NULL; | |
| if (fMonetary) { | |
| newRules = PluralRules::forLocale(fSymbols->getLocale(), status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| } | |
| // Its ok to say a field has changed when it really hasn't but not | |
| // the other way around. Here we assume the field changed unless it | |
| // was NULL before and is still NULL now | |
| if (fRules != newRules) { | |
| delete fRules; | |
| fRules = newRules; | |
| changedFormattingFields |= kFormattingPluralRules; | |
| } | |
| } | |
| void | |
| DecimalFormatImpl::updateFormattingCurrencyAffixInfo( | |
| int32_t &changedFormattingFields, | |
| UBool updatePrecisionBasedOnCurrency, | |
| UErrorCode &status) { | |
| if ((changedFormattingFields & ( | |
| kFormattingSymbols | kFormattingCurrency | | |
| kFormattingUsesCurrency | kFormattingPluralRules)) == 0) { | |
| // If all these fields are unchanged, no work to do. | |
| return; | |
| } | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| if (!fMonetary) { | |
| if (fCurrencyAffixInfo.isDefault()) { | |
| // In this case don't have to do any work | |
| return; | |
| } | |
| fCurrencyAffixInfo.set(NULL, NULL, NULL, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| changedFormattingFields |= kFormattingCurrencyAffixInfo; | |
| } else { | |
| const UChar *currency = fSuper->getCurrency(); | |
| UChar localeCurr[4]; | |
| if (currency[0] == 0) { | |
| ucurr_forLocale(fSymbols->getLocale().getName(), localeCurr, UPRV_LENGTHOF(localeCurr), &status); | |
| if (U_SUCCESS(status)) { | |
| currency = localeCurr; | |
| fSuper->NumberFormat::setCurrency(currency, status); | |
| } else { | |
| currency = NULL; | |
| status = U_ZERO_ERROR; | |
| } | |
| } | |
| fCurrencyAffixInfo.set( | |
| fSymbols->getLocale().getName(), fRules, currency, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| UBool customCurrencySymbol = FALSE; | |
| // If DecimalFormatSymbols has custom currency symbol, prefer | |
| // that over what we just read from the resource bundles | |
| if (fSymbols->isCustomCurrencySymbol()) { | |
| fCurrencyAffixInfo.setSymbol( | |
| fSymbols->getConstSymbol(DecimalFormatSymbols::kCurrencySymbol)); | |
| customCurrencySymbol = TRUE; | |
| } | |
| if (fSymbols->isCustomIntlCurrencySymbol()) { | |
| fCurrencyAffixInfo.setISO( | |
| fSymbols->getConstSymbol(DecimalFormatSymbols::kIntlCurrencySymbol)); | |
| customCurrencySymbol = TRUE; | |
| } | |
| changedFormattingFields |= kFormattingCurrencyAffixInfo; | |
| if (currency && !customCurrencySymbol && updatePrecisionBasedOnCurrency) { | |
| FixedPrecision precision; | |
| CurrencyAffixInfo::adjustPrecision( | |
| currency, fCurrencyUsage, precision, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| fSuper->NumberFormat::setMinimumFractionDigits( | |
| precision.fMin.getFracDigitCount()); | |
| fSuper->NumberFormat::setMaximumFractionDigits( | |
| precision.fMax.getFracDigitCount()); | |
| updatePrecision(); | |
| fEffPrecision.fMantissa.fRoundingIncrement = | |
| precision.fRoundingIncrement; | |
| } | |
| } | |
| } | |
| void | |
| DecimalFormatImpl::updateFormattingFixedPointFormatter( | |
| int32_t &changedFormattingFields) { | |
| if ((changedFormattingFields & (kFormattingSymbols | kFormattingUsesCurrency)) == 0) { | |
| // No work to do if fSymbols is unchanged | |
| return; | |
| } | |
| if (fMonetary) { | |
| fFormatter.setDecimalFormatSymbolsForMonetary(*fSymbols); | |
| } else { | |
| fFormatter.setDecimalFormatSymbols(*fSymbols); | |
| } | |
| } | |
| void | |
| DecimalFormatImpl::updateFormattingAffixParser( | |
| int32_t &changedFormattingFields) { | |
| if ((changedFormattingFields & kFormattingSymbols) == 0) { | |
| // No work to do if fSymbols is unchanged | |
| return; | |
| } | |
| fAffixParser.setDecimalFormatSymbols(*fSymbols); | |
| changedFormattingFields |= kFormattingAffixParser; | |
| } | |
| void | |
| DecimalFormatImpl::updateFormattingLocalizedPositivePrefix( | |
| int32_t &changedFormattingFields, UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| if ((changedFormattingFields & ( | |
| kFormattingPosPrefix | kFormattingAffixParserWithCurrency)) == 0) { | |
| // No work to do | |
| return; | |
| } | |
| fAffixes.fPositivePrefix.remove(); | |
| fAffixParser.parse( | |
| fPositivePrefixPattern, | |
| fCurrencyAffixInfo, | |
| fAffixes.fPositivePrefix, | |
| status); | |
| } | |
| void | |
| DecimalFormatImpl::updateFormattingLocalizedPositiveSuffix( | |
| int32_t &changedFormattingFields, UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| if ((changedFormattingFields & ( | |
| kFormattingPosSuffix | kFormattingAffixParserWithCurrency)) == 0) { | |
| // No work to do | |
| return; | |
| } | |
| fAffixes.fPositiveSuffix.remove(); | |
| fAffixParser.parse( | |
| fPositiveSuffixPattern, | |
| fCurrencyAffixInfo, | |
| fAffixes.fPositiveSuffix, | |
| status); | |
| } | |
| void | |
| DecimalFormatImpl::updateFormattingLocalizedNegativePrefix( | |
| int32_t &changedFormattingFields, UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| if ((changedFormattingFields & ( | |
| kFormattingNegPrefix | kFormattingAffixParserWithCurrency)) == 0) { | |
| // No work to do | |
| return; | |
| } | |
| fAffixes.fNegativePrefix.remove(); | |
| fAffixParser.parse( | |
| fNegativePrefixPattern, | |
| fCurrencyAffixInfo, | |
| fAffixes.fNegativePrefix, | |
| status); | |
| } | |
| void | |
| DecimalFormatImpl::updateFormattingLocalizedNegativeSuffix( | |
| int32_t &changedFormattingFields, UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| if ((changedFormattingFields & ( | |
| kFormattingNegSuffix | kFormattingAffixParserWithCurrency)) == 0) { | |
| // No work to do | |
| return; | |
| } | |
| fAffixes.fNegativeSuffix.remove(); | |
| fAffixParser.parse( | |
| fNegativeSuffixPattern, | |
| fCurrencyAffixInfo, | |
| fAffixes.fNegativeSuffix, | |
| status); | |
| } | |
| void | |
| DecimalFormatImpl::updateForApplyPatternFavorCurrencyPrecision( | |
| UErrorCode &status) { | |
| updateAll(kFormattingAll & ~kFormattingSymbols, TRUE, status); | |
| } | |
| void | |
| DecimalFormatImpl::updateForApplyPattern(UErrorCode &status) { | |
| updateAll(kFormattingAll & ~kFormattingSymbols, FALSE, status); | |
| } | |
| void | |
| DecimalFormatImpl::updateAll(UErrorCode &status) { | |
| updateAll(kFormattingAll, TRUE, status); | |
| } | |
| void | |
| DecimalFormatImpl::updateAll( | |
| int32_t formattingFlags, | |
| UBool updatePrecisionBasedOnCurrency, | |
| UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| updatePrecision(); | |
| updateGrouping(); | |
| updateFormatting( | |
| formattingFlags, updatePrecisionBasedOnCurrency, status); | |
| setMultiplierScale(getPatternScale()); | |
| } | |
| static int32_t | |
| getMinimumLengthToDescribeGrouping(const DigitGrouping &grouping) { | |
| if (grouping.fGrouping <= 0) { | |
| return 0; | |
| } | |
| if (grouping.fGrouping2 <= 0) { | |
| return grouping.fGrouping + 1; | |
| } | |
| return grouping.fGrouping + grouping.fGrouping2 + 1; | |
| } | |
| /** | |
| * Given a grouping policy, calculates how many digits are needed left of | |
| * the decimal point to achieve a desired length left of the | |
| * decimal point. | |
| * @param grouping the grouping policy | |
| * @param desiredLength number of characters needed left of decimal point | |
| * @param minLeftDigits at least this many digits is returned | |
| * @param leftDigits the number of digits needed stored here | |
| * which is >= minLeftDigits. | |
| * @return true if a perfect fit or false if having leftDigits would exceed | |
| * desiredLength | |
| */ | |
| static UBool | |
| getLeftDigitsForLeftLength( | |
| const DigitGrouping &grouping, | |
| int32_t desiredLength, | |
| int32_t minLeftDigits, | |
| int32_t &leftDigits) { | |
| leftDigits = minLeftDigits; | |
| int32_t lengthSoFar = leftDigits + grouping.getSeparatorCount(leftDigits); | |
| while (lengthSoFar < desiredLength) { | |
| lengthSoFar += grouping.isSeparatorAt(leftDigits + 1, leftDigits) ? 2 : 1; | |
| ++leftDigits; | |
| } | |
| return (lengthSoFar == desiredLength); | |
| } | |
| int32_t | |
| DecimalFormatImpl::computeExponentPatternLength() const { | |
| if (fUseScientific) { | |
| return 1 + (fOptions.fExponent.fAlwaysShowSign ? 1 : 0) + fEffPrecision.fMinExponentDigits; | |
| } | |
| return 0; | |
| } | |
| int32_t | |
| DecimalFormatImpl::countFractionDigitAndDecimalPatternLength( | |
| int32_t fracDigitCount) const { | |
| if (!fOptions.fMantissa.fAlwaysShowDecimal && fracDigitCount == 0) { | |
| return 0; | |
| } | |
| return fracDigitCount + 1; | |
| } | |
| UnicodeString& | |
| DecimalFormatImpl::toNumberPattern( | |
| UBool hasPadding, int32_t minimumLength, UnicodeString& result) const { | |
| // Get a grouping policy like the one in this object that does not | |
| // have minimum grouping since toPattern doesn't support it. | |
| DigitGrouping grouping(fEffGrouping); | |
| grouping.fMinGrouping = 0; | |
| // Only for fixed digits, these are the digits that get 0's. | |
| DigitInterval minInterval; | |
| // Only for fixed digits, these are the digits that get #'s. | |
| DigitInterval maxInterval; | |
| // Only for significant digits | |
| int32_t sigMin; | |
| int32_t sigMax; | |
| // These are all the digits to be displayed. For significant digits, | |
| // this interval always starts at the 1's place an extends left. | |
| DigitInterval fullInterval; | |
| // Digit range of rounding increment. If rounding increment is .025. | |
| // then roundingIncrementLowerExp = -3 and roundingIncrementUpperExp = -1 | |
| int32_t roundingIncrementLowerExp = 0; | |
| int32_t roundingIncrementUpperExp = 0; | |
| if (fUseSigDigits) { | |
| SignificantDigitInterval sigInterval; | |
| extractSigDigits(sigInterval); | |
| sigMax = sigInterval.getMax(); | |
| sigMin = sigInterval.getMin(); | |
| fullInterval.setFracDigitCount(0); | |
| fullInterval.setIntDigitCount(sigMax); | |
| } else { | |
| extractMinMaxDigits(minInterval, maxInterval); | |
| if (fUseScientific) { | |
| if (maxInterval.getIntDigitCount() > kMaxScientificIntegerDigits) { | |
| maxInterval.setIntDigitCount(1); | |
| minInterval.shrinkToFitWithin(maxInterval); | |
| } | |
| } else if (hasPadding) { | |
| // Make max int digits match min int digits for now, we | |
| // compute necessary padding later. | |
| maxInterval.setIntDigitCount(minInterval.getIntDigitCount()); | |
| } else { | |
| // For some reason toPattern adds at least one leading '#' | |
| maxInterval.setIntDigitCount(minInterval.getIntDigitCount() + 1); | |
| } | |
| if (!fEffPrecision.fMantissa.fRoundingIncrement.isZero()) { | |
| roundingIncrementLowerExp = | |
| fEffPrecision.fMantissa.fRoundingIncrement.getLowerExponent(); | |
| roundingIncrementUpperExp = | |
| fEffPrecision.fMantissa.fRoundingIncrement.getUpperExponent(); | |
| // We have to include the rounding increment in what we display | |
| maxInterval.expandToContainDigit(roundingIncrementLowerExp); | |
| maxInterval.expandToContainDigit(roundingIncrementUpperExp - 1); | |
| } | |
| fullInterval = maxInterval; | |
| } | |
| // We have to include enough digits to show grouping strategy | |
| int32_t minLengthToDescribeGrouping = | |
| getMinimumLengthToDescribeGrouping(grouping); | |
| if (minLengthToDescribeGrouping > 0) { | |
| fullInterval.expandToContainDigit( | |
| getMinimumLengthToDescribeGrouping(grouping) - 1); | |
| } | |
| // If we have a minimum length, we have to add digits to the left to | |
| // depict padding. | |
| if (hasPadding) { | |
| // For non scientific notation, | |
| // minimumLengthForMantissa = minimumLength | |
| int32_t minimumLengthForMantissa = | |
| minimumLength - computeExponentPatternLength(); | |
| int32_t mininumLengthForMantissaIntPart = | |
| minimumLengthForMantissa | |
| - countFractionDigitAndDecimalPatternLength( | |
| fullInterval.getFracDigitCount()); | |
| // Because of grouping, we may need fewer than expected digits to | |
| // achieve the length we need. | |
| int32_t digitsNeeded; | |
| if (getLeftDigitsForLeftLength( | |
| grouping, | |
| mininumLengthForMantissaIntPart, | |
| fullInterval.getIntDigitCount(), | |
| digitsNeeded)) { | |
| // In this case, we achieved the exact length that we want. | |
| fullInterval.setIntDigitCount(digitsNeeded); | |
| } else if (digitsNeeded > fullInterval.getIntDigitCount()) { | |
| // Having digitsNeeded digits goes over desired length which | |
| // means that to have desired length would mean starting on a | |
| // grouping sepearator e.g ,###,### so add a '#' and use one | |
| // less digit. This trick gives ####,### but that is the best | |
| // we can do. | |
| result.append(kPatternDigit); | |
| fullInterval.setIntDigitCount(digitsNeeded - 1); | |
| } | |
| } | |
| int32_t maxDigitPos = fullInterval.getMostSignificantExclusive(); | |
| int32_t minDigitPos = fullInterval.getLeastSignificantInclusive(); | |
| for (int32_t i = maxDigitPos - 1; i >= minDigitPos; --i) { | |
| if (!fOptions.fMantissa.fAlwaysShowDecimal && i == -1) { | |
| result.append(kPatternDecimalSeparator); | |
| } | |
| if (fUseSigDigits) { | |
| // Use digit symbol | |
| if (i >= sigMax || i < sigMax - sigMin) { | |
| result.append(kPatternDigit); | |
| } else { | |
| result.append(kPatternSignificantDigit); | |
| } | |
| } else { | |
| if (i < roundingIncrementUpperExp && i >= roundingIncrementLowerExp) { | |
| result.append(fEffPrecision.fMantissa.fRoundingIncrement.getDigitByExponent(i) + kPatternZeroDigit); | |
| } else if (minInterval.contains(i)) { | |
| result.append(kPatternZeroDigit); | |
| } else { | |
| result.append(kPatternDigit); | |
| } | |
| } | |
| if (grouping.isSeparatorAt(i + 1, i)) { | |
| result.append(kPatternGroupingSeparator); | |
| } | |
| if (fOptions.fMantissa.fAlwaysShowDecimal && i == 0) { | |
| result.append(kPatternDecimalSeparator); | |
| } | |
| } | |
| if (fUseScientific) { | |
| result.append(kPatternExponent); | |
| if (fOptions.fExponent.fAlwaysShowSign) { | |
| result.append(kPatternPlus); | |
| } | |
| for (int32_t i = 0; i < 1 || i < fEffPrecision.fMinExponentDigits; ++i) { | |
| result.append(kPatternZeroDigit); | |
| } | |
| } | |
| return result; | |
| } | |
| UnicodeString& | |
| DecimalFormatImpl::toPattern(UnicodeString& result) const { | |
| result.remove(); | |
| UnicodeString padSpec; | |
| if (fAffixes.fWidth > 0) { | |
| padSpec.append(kPatternPadEscape); | |
| padSpec.append(fAffixes.fPadChar); | |
| } | |
| if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforePrefix) { | |
| result.append(padSpec); | |
| } | |
| fPositivePrefixPattern.toUserString(result); | |
| if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterPrefix) { | |
| result.append(padSpec); | |
| } | |
| toNumberPattern( | |
| fAffixes.fWidth > 0, | |
| fAffixes.fWidth - fPositivePrefixPattern.countChar32() - fPositiveSuffixPattern.countChar32(), | |
| result); | |
| if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforeSuffix) { | |
| result.append(padSpec); | |
| } | |
| fPositiveSuffixPattern.toUserString(result); | |
| if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterSuffix) { | |
| result.append(padSpec); | |
| } | |
| AffixPattern withNegative; | |
| withNegative.add(AffixPattern::kNegative); | |
| withNegative.append(fPositivePrefixPattern); | |
| if (!fPositiveSuffixPattern.equals(fNegativeSuffixPattern) || | |
| !withNegative.equals(fNegativePrefixPattern)) { | |
| result.append(kPatternSeparator); | |
| if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforePrefix) { | |
| result.append(padSpec); | |
| } | |
| fNegativePrefixPattern.toUserString(result); | |
| if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterPrefix) { | |
| result.append(padSpec); | |
| } | |
| toNumberPattern( | |
| fAffixes.fWidth > 0, | |
| fAffixes.fWidth - fNegativePrefixPattern.countChar32() - fNegativeSuffixPattern.countChar32(), | |
| result); | |
| if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforeSuffix) { | |
| result.append(padSpec); | |
| } | |
| fNegativeSuffixPattern.toUserString(result); | |
| if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterSuffix) { | |
| result.append(padSpec); | |
| } | |
| } | |
| return result; | |
| } | |
| int32_t | |
| DecimalFormatImpl::getOldFormatWidth() const { | |
| if (fAffixes.fWidth == 0) { | |
| return 0; | |
| } | |
| return fAffixes.fWidth - fPositiveSuffixPattern.countChar32() - fPositivePrefixPattern.countChar32(); | |
| } | |
| const UnicodeString & | |
| DecimalFormatImpl::getConstSymbol( | |
| DecimalFormatSymbols::ENumberFormatSymbol symbol) const { | |
| return fSymbols->getConstSymbol(symbol); | |
| } | |
| UBool | |
| DecimalFormatImpl::isParseFastpath() const { | |
| AffixPattern negative; | |
| negative.add(AffixPattern::kNegative); | |
| return fAffixes.fWidth == 0 && | |
| fPositivePrefixPattern.countChar32() == 0 && | |
| fNegativePrefixPattern.equals(negative) && | |
| fPositiveSuffixPattern.countChar32() == 0 && | |
| fNegativeSuffixPattern.countChar32() == 0; | |
| } | |
| U_NAMESPACE_END | |
| #endif /* #if !UCONFIG_NO_FORMATTING */ | |