| /* |
| * Copyright (C) 2015, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| * |
| * file name: decimfmtimpl.cpp |
| */ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_FORMATTING |
| #if defined(STARBOARD) |
| #include "starboard/client_porting/poem/string_poem.h" |
| #else |
| #include <math.h> |
| #endif // defined(STARBOARD) |
| #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 */ |
| |
