scuffed-code/icu4c/source/i18n/decimfmtimpl.cpp

1597 lines
51 KiB
C++
Raw Normal View History

// Copyright (C) 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
* 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 <math.h>
#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 */