337 lines
14 KiB
C++
337 lines
14 KiB
C++
// © 2017 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_FORMATTING
|
|
|
|
#include "cstring.h"
|
|
#include "number_patternmodifier.h"
|
|
#include "unicode/dcfmtsym.h"
|
|
#include "unicode/ucurr.h"
|
|
#include "unicode/unistr.h"
|
|
#include "number_microprops.h"
|
|
|
|
using namespace icu;
|
|
using namespace icu::number;
|
|
using namespace icu::number::impl;
|
|
|
|
|
|
AffixPatternProvider::~AffixPatternProvider() = default;
|
|
|
|
|
|
MutablePatternModifier::MutablePatternModifier(bool isStrong)
|
|
: fStrong(isStrong) {}
|
|
|
|
void MutablePatternModifier::setPatternInfo(const AffixPatternProvider* patternInfo, Field field) {
|
|
fPatternInfo = patternInfo;
|
|
fField = field;
|
|
}
|
|
|
|
void MutablePatternModifier::setPatternAttributes(UNumberSignDisplay signDisplay, bool perMille) {
|
|
fSignDisplay = signDisplay;
|
|
fPerMilleReplacesPercent = perMille;
|
|
}
|
|
|
|
void MutablePatternModifier::setSymbols(const DecimalFormatSymbols* symbols,
|
|
const CurrencyUnit& currency,
|
|
const UNumberUnitWidth unitWidth,
|
|
const PluralRules* rules,
|
|
UErrorCode& status) {
|
|
U_ASSERT((rules != nullptr) == needsPlurals());
|
|
fSymbols = symbols;
|
|
fCurrencySymbols = {currency, symbols->getLocale(), *symbols, status};
|
|
fUnitWidth = unitWidth;
|
|
fRules = rules;
|
|
}
|
|
|
|
void MutablePatternModifier::setNumberProperties(Signum signum, StandardPlural::Form plural) {
|
|
fSignum = signum;
|
|
fPlural = plural;
|
|
}
|
|
|
|
bool MutablePatternModifier::needsPlurals() const {
|
|
UErrorCode statusLocal = U_ZERO_ERROR;
|
|
return fPatternInfo->containsSymbolType(AffixPatternType::TYPE_CURRENCY_TRIPLE, statusLocal);
|
|
// Silently ignore any error codes.
|
|
}
|
|
|
|
ImmutablePatternModifier* MutablePatternModifier::createImmutable(UErrorCode& status) {
|
|
// TODO: Move StandardPlural VALUES to standardplural.h
|
|
static const StandardPlural::Form STANDARD_PLURAL_VALUES[] = {
|
|
StandardPlural::Form::ZERO,
|
|
StandardPlural::Form::ONE,
|
|
StandardPlural::Form::TWO,
|
|
StandardPlural::Form::FEW,
|
|
StandardPlural::Form::MANY,
|
|
StandardPlural::Form::OTHER};
|
|
|
|
auto pm = new AdoptingModifierStore();
|
|
if (pm == nullptr) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return nullptr;
|
|
}
|
|
|
|
if (needsPlurals()) {
|
|
// Slower path when we require the plural keyword.
|
|
for (StandardPlural::Form plural : STANDARD_PLURAL_VALUES) {
|
|
setNumberProperties(SIGNUM_POS, plural);
|
|
pm->adoptModifier(SIGNUM_POS, plural, createConstantModifier(status));
|
|
setNumberProperties(SIGNUM_NEG_ZERO, plural);
|
|
pm->adoptModifier(SIGNUM_NEG_ZERO, plural, createConstantModifier(status));
|
|
setNumberProperties(SIGNUM_POS_ZERO, plural);
|
|
pm->adoptModifier(SIGNUM_POS_ZERO, plural, createConstantModifier(status));
|
|
setNumberProperties(SIGNUM_NEG, plural);
|
|
pm->adoptModifier(SIGNUM_NEG, plural, createConstantModifier(status));
|
|
}
|
|
if (U_FAILURE(status)) {
|
|
delete pm;
|
|
return nullptr;
|
|
}
|
|
return new ImmutablePatternModifier(pm, fRules); // adopts pm
|
|
} else {
|
|
// Faster path when plural keyword is not needed.
|
|
setNumberProperties(SIGNUM_POS, StandardPlural::Form::COUNT);
|
|
pm->adoptModifierWithoutPlural(SIGNUM_POS, createConstantModifier(status));
|
|
setNumberProperties(SIGNUM_NEG_ZERO, StandardPlural::Form::COUNT);
|
|
pm->adoptModifierWithoutPlural(SIGNUM_NEG_ZERO, createConstantModifier(status));
|
|
setNumberProperties(SIGNUM_POS_ZERO, StandardPlural::Form::COUNT);
|
|
pm->adoptModifierWithoutPlural(SIGNUM_POS_ZERO, createConstantModifier(status));
|
|
setNumberProperties(SIGNUM_NEG, StandardPlural::Form::COUNT);
|
|
pm->adoptModifierWithoutPlural(SIGNUM_NEG, createConstantModifier(status));
|
|
if (U_FAILURE(status)) {
|
|
delete pm;
|
|
return nullptr;
|
|
}
|
|
return new ImmutablePatternModifier(pm, nullptr); // adopts pm
|
|
}
|
|
}
|
|
|
|
ConstantMultiFieldModifier* MutablePatternModifier::createConstantModifier(UErrorCode& status) {
|
|
FormattedStringBuilder a;
|
|
FormattedStringBuilder b;
|
|
insertPrefix(a, 0, status);
|
|
insertSuffix(b, 0, status);
|
|
if (fPatternInfo->hasCurrencySign()) {
|
|
return new CurrencySpacingEnabledModifier(
|
|
a, b, !fPatternInfo->hasBody(), fStrong, *fSymbols, status);
|
|
} else {
|
|
return new ConstantMultiFieldModifier(a, b, !fPatternInfo->hasBody(), fStrong);
|
|
}
|
|
}
|
|
|
|
ImmutablePatternModifier::ImmutablePatternModifier(AdoptingModifierStore* pm, const PluralRules* rules)
|
|
: pm(pm), rules(rules), parent(nullptr) {}
|
|
|
|
void ImmutablePatternModifier::processQuantity(DecimalQuantity& quantity, MicroProps& micros,
|
|
UErrorCode& status) const {
|
|
parent->processQuantity(quantity, micros, status);
|
|
micros.rounder.apply(quantity, status);
|
|
if (micros.modMiddle != nullptr) {
|
|
return;
|
|
}
|
|
applyToMicros(micros, quantity, status);
|
|
}
|
|
|
|
void ImmutablePatternModifier::applyToMicros(
|
|
MicroProps& micros, const DecimalQuantity& quantity, UErrorCode& status) const {
|
|
if (rules == nullptr) {
|
|
micros.modMiddle = pm->getModifierWithoutPlural(quantity.signum());
|
|
} else {
|
|
StandardPlural::Form pluralForm = utils::getPluralSafe(micros.rounder, rules, quantity, status);
|
|
micros.modMiddle = pm->getModifier(quantity.signum(), pluralForm);
|
|
}
|
|
}
|
|
|
|
const Modifier* ImmutablePatternModifier::getModifier(Signum signum, StandardPlural::Form plural) const {
|
|
if (rules == nullptr) {
|
|
return pm->getModifierWithoutPlural(signum);
|
|
} else {
|
|
return pm->getModifier(signum, plural);
|
|
}
|
|
}
|
|
|
|
void ImmutablePatternModifier::addToChain(const MicroPropsGenerator* parent) {
|
|
this->parent = parent;
|
|
}
|
|
|
|
|
|
/** Used by the unsafe code path. */
|
|
MicroPropsGenerator& MutablePatternModifier::addToChain(const MicroPropsGenerator* parent) {
|
|
fParent = parent;
|
|
return *this;
|
|
}
|
|
|
|
void MutablePatternModifier::processQuantity(DecimalQuantity& fq, MicroProps& micros,
|
|
UErrorCode& status) const {
|
|
fParent->processQuantity(fq, micros, status);
|
|
micros.rounder.apply(fq, status);
|
|
if (micros.modMiddle != nullptr) {
|
|
return;
|
|
}
|
|
// The unsafe code path performs self-mutation, so we need a const_cast.
|
|
// This method needs to be const because it overrides a const method in the parent class.
|
|
auto nonConstThis = const_cast<MutablePatternModifier*>(this);
|
|
if (needsPlurals()) {
|
|
StandardPlural::Form pluralForm = utils::getPluralSafe(micros.rounder, fRules, fq, status);
|
|
nonConstThis->setNumberProperties(fq.signum(), pluralForm);
|
|
} else {
|
|
nonConstThis->setNumberProperties(fq.signum(), StandardPlural::Form::COUNT);
|
|
}
|
|
micros.modMiddle = this;
|
|
}
|
|
|
|
int32_t MutablePatternModifier::apply(FormattedStringBuilder& output, int32_t leftIndex, int32_t rightIndex,
|
|
UErrorCode& status) const {
|
|
// The unsafe code path performs self-mutation, so we need a const_cast.
|
|
// This method needs to be const because it overrides a const method in the parent class.
|
|
auto nonConstThis = const_cast<MutablePatternModifier*>(this);
|
|
int32_t prefixLen = nonConstThis->insertPrefix(output, leftIndex, status);
|
|
int32_t suffixLen = nonConstThis->insertSuffix(output, rightIndex + prefixLen, status);
|
|
// If the pattern had no decimal stem body (like #,##0.00), overwrite the value.
|
|
int32_t overwriteLen = 0;
|
|
if (!fPatternInfo->hasBody()) {
|
|
overwriteLen = output.splice(
|
|
leftIndex + prefixLen,
|
|
rightIndex + prefixLen,
|
|
UnicodeString(),
|
|
0,
|
|
0,
|
|
kUndefinedField,
|
|
status);
|
|
}
|
|
CurrencySpacingEnabledModifier::applyCurrencySpacing(
|
|
output,
|
|
leftIndex,
|
|
prefixLen,
|
|
rightIndex + overwriteLen + prefixLen,
|
|
suffixLen,
|
|
*fSymbols,
|
|
status);
|
|
return prefixLen + overwriteLen + suffixLen;
|
|
}
|
|
|
|
int32_t MutablePatternModifier::getPrefixLength() const {
|
|
// The unsafe code path performs self-mutation, so we need a const_cast.
|
|
// This method needs to be const because it overrides a const method in the parent class.
|
|
auto nonConstThis = const_cast<MutablePatternModifier*>(this);
|
|
|
|
// Enter and exit CharSequence Mode to get the length.
|
|
UErrorCode status = U_ZERO_ERROR; // status fails only with an iilegal argument exception
|
|
nonConstThis->prepareAffix(true);
|
|
int result = AffixUtils::unescapedCodePointCount(currentAffix, *this, status); // prefix length
|
|
return result;
|
|
}
|
|
|
|
int32_t MutablePatternModifier::getCodePointCount() const {
|
|
// The unsafe code path performs self-mutation, so we need a const_cast.
|
|
// This method needs to be const because it overrides a const method in the parent class.
|
|
auto nonConstThis = const_cast<MutablePatternModifier*>(this);
|
|
|
|
// Render the affixes to get the length
|
|
UErrorCode status = U_ZERO_ERROR; // status fails only with an iilegal argument exception
|
|
nonConstThis->prepareAffix(true);
|
|
int result = AffixUtils::unescapedCodePointCount(currentAffix, *this, status); // prefix length
|
|
nonConstThis->prepareAffix(false);
|
|
result += AffixUtils::unescapedCodePointCount(currentAffix, *this, status); // suffix length
|
|
return result;
|
|
}
|
|
|
|
bool MutablePatternModifier::isStrong() const {
|
|
return fStrong;
|
|
}
|
|
|
|
bool MutablePatternModifier::containsField(Field field) const {
|
|
(void)field;
|
|
// This method is not currently used.
|
|
UPRV_UNREACHABLE;
|
|
}
|
|
|
|
void MutablePatternModifier::getParameters(Parameters& output) const {
|
|
(void)output;
|
|
// This method is not currently used.
|
|
UPRV_UNREACHABLE;
|
|
}
|
|
|
|
bool MutablePatternModifier::semanticallyEquivalent(const Modifier& other) const {
|
|
(void)other;
|
|
// This method is not currently used.
|
|
UPRV_UNREACHABLE;
|
|
}
|
|
|
|
int32_t MutablePatternModifier::insertPrefix(FormattedStringBuilder& sb, int position, UErrorCode& status) {
|
|
prepareAffix(true);
|
|
int32_t length = AffixUtils::unescape(currentAffix, sb, position, *this, fField, status);
|
|
return length;
|
|
}
|
|
|
|
int32_t MutablePatternModifier::insertSuffix(FormattedStringBuilder& sb, int position, UErrorCode& status) {
|
|
prepareAffix(false);
|
|
int32_t length = AffixUtils::unescape(currentAffix, sb, position, *this, fField, status);
|
|
return length;
|
|
}
|
|
|
|
/** This method contains the heart of the logic for rendering LDML affix strings. */
|
|
void MutablePatternModifier::prepareAffix(bool isPrefix) {
|
|
PatternStringUtils::patternInfoToStringBuilder(
|
|
*fPatternInfo,
|
|
isPrefix,
|
|
PatternStringUtils::resolveSignDisplay(fSignDisplay, fSignum),
|
|
fPlural,
|
|
fPerMilleReplacesPercent,
|
|
currentAffix);
|
|
}
|
|
|
|
UnicodeString MutablePatternModifier::getSymbol(AffixPatternType type) const {
|
|
UErrorCode localStatus = U_ZERO_ERROR;
|
|
switch (type) {
|
|
case AffixPatternType::TYPE_MINUS_SIGN:
|
|
return fSymbols->getSymbol(DecimalFormatSymbols::ENumberFormatSymbol::kMinusSignSymbol);
|
|
case AffixPatternType::TYPE_PLUS_SIGN:
|
|
return fSymbols->getSymbol(DecimalFormatSymbols::ENumberFormatSymbol::kPlusSignSymbol);
|
|
case AffixPatternType::TYPE_PERCENT:
|
|
return fSymbols->getSymbol(DecimalFormatSymbols::ENumberFormatSymbol::kPercentSymbol);
|
|
case AffixPatternType::TYPE_PERMILLE:
|
|
return fSymbols->getSymbol(DecimalFormatSymbols::ENumberFormatSymbol::kPerMillSymbol);
|
|
case AffixPatternType::TYPE_CURRENCY_SINGLE: {
|
|
switch (fUnitWidth) {
|
|
case UNumberUnitWidth::UNUM_UNIT_WIDTH_NARROW:
|
|
return fCurrencySymbols.getNarrowCurrencySymbol(localStatus);
|
|
case UNumberUnitWidth::UNUM_UNIT_WIDTH_SHORT:
|
|
return fCurrencySymbols.getCurrencySymbol(localStatus);
|
|
case UNumberUnitWidth::UNUM_UNIT_WIDTH_ISO_CODE:
|
|
return fCurrencySymbols.getIntlCurrencySymbol(localStatus);
|
|
case UNumberUnitWidth::UNUM_UNIT_WIDTH_FORMAL:
|
|
return fCurrencySymbols.getFormalCurrencySymbol(localStatus);
|
|
case UNumberUnitWidth::UNUM_UNIT_WIDTH_VARIANT:
|
|
return fCurrencySymbols.getVariantCurrencySymbol(localStatus);
|
|
case UNumberUnitWidth::UNUM_UNIT_WIDTH_HIDDEN:
|
|
return UnicodeString();
|
|
default:
|
|
return fCurrencySymbols.getCurrencySymbol(localStatus);
|
|
}
|
|
}
|
|
case AffixPatternType::TYPE_CURRENCY_DOUBLE:
|
|
return fCurrencySymbols.getIntlCurrencySymbol(localStatus);
|
|
case AffixPatternType::TYPE_CURRENCY_TRIPLE:
|
|
// NOTE: This is the code path only for patterns containing "¤¤¤".
|
|
// Plural currencies set via the API are formatted in LongNameHandler.
|
|
// This code path is used by DecimalFormat via CurrencyPluralInfo.
|
|
U_ASSERT(fPlural != StandardPlural::Form::COUNT);
|
|
return fCurrencySymbols.getPluralName(fPlural, localStatus);
|
|
case AffixPatternType::TYPE_CURRENCY_QUAD:
|
|
return UnicodeString(u"\uFFFD");
|
|
case AffixPatternType::TYPE_CURRENCY_QUINT:
|
|
return UnicodeString(u"\uFFFD");
|
|
default:
|
|
UPRV_UNREACHABLE;
|
|
}
|
|
}
|
|
|
|
UnicodeString MutablePatternModifier::toUnicodeString() const {
|
|
// Never called by AffixUtils
|
|
UPRV_UNREACHABLE;
|
|
}
|
|
|
|
#endif /* #if !UCONFIG_NO_FORMATTING */
|