1597 lines
51 KiB
C++
1597 lines
51 KiB
C++
// 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 */
|
|
|