chromium/third_party/icu/source/i18n/number_modifiers.cpp

// © 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 "umutex.h"
#include "ucln_cmn.h"
#include "ucln_in.h"
#include "number_modifiers.h"

usingnamespaceicu;
usingnamespaceicu::number;
usingnamespaceicu::number::impl;

namespace {

// TODO: This is copied from simpleformatter.cpp
const int32_t ARG_NUM_LIMIT = …;

// These are the default currency spacing UnicodeSets in CLDR.
// Pre-compute them for performance.
// The Java unit test testCurrencySpacingPatternStability() will start failing if these change in CLDR.
icu::UInitOnce gDefaultCurrencySpacingInitOnce { … };

UnicodeSet *UNISET_DIGIT = …;
UnicodeSet *UNISET_NOTSZ = …;

UBool U_CALLCONV cleanupDefaultCurrencySpacing() { … }

void U_CALLCONV initDefaultCurrencySpacing(UErrorCode &status) { … }

}  // namespace


Modifier::~Modifier() = default;

Modifier::Parameters::Parameters()
        : … { … }

Modifier::Parameters::Parameters(
    const ModifierStore* _obj, Signum _signum, StandardPlural::Form _plural)
        : … { … }

ModifierStore::~ModifierStore() = default;

AdoptingSignumModifierStore::~AdoptingSignumModifierStore()  { … }

AdoptingSignumModifierStore&
AdoptingSignumModifierStore::operator=(AdoptingSignumModifierStore&& other) noexcept { … }


int32_t ConstantAffixModifier::apply(FormattedStringBuilder &output, int leftIndex, int rightIndex,
                                     UErrorCode &status) const { … }

int32_t ConstantAffixModifier::getPrefixLength() const { … }

int32_t ConstantAffixModifier::getCodePointCount() const { … }

bool ConstantAffixModifier::isStrong() const { … }

bool ConstantAffixModifier::containsField(Field field) const { … }

void ConstantAffixModifier::getParameters(Parameters& output) const { … }

bool ConstantAffixModifier::semanticallyEquivalent(const Modifier& other) const { … }


SimpleModifier::SimpleModifier(const SimpleFormatter &simpleFormatter, Field field, bool strong)
        : … { … }

SimpleModifier::SimpleModifier(const SimpleFormatter &simpleFormatter, Field field, bool strong,
                               const Modifier::Parameters parameters)
        : … { … }

SimpleModifier::SimpleModifier()
        : … { … }

int32_t SimpleModifier::apply(FormattedStringBuilder &output, int leftIndex, int rightIndex,
                              UErrorCode &status) const { … }

int32_t SimpleModifier::getPrefixLength() const { … }

int32_t SimpleModifier::getCodePointCount() const { … }

bool SimpleModifier::isStrong() const { … }

bool SimpleModifier::containsField(Field field) const { … }

void SimpleModifier::getParameters(Parameters& output) const { … }

bool SimpleModifier::semanticallyEquivalent(const Modifier& other) const { … }


int32_t
SimpleModifier::formatAsPrefixSuffix(FormattedStringBuilder &result, int32_t startIndex, int32_t endIndex,
                                     UErrorCode &status) const { … }


int32_t
SimpleModifier::formatTwoArgPattern(const SimpleFormatter& compiled, FormattedStringBuilder& result,
                                    int32_t index, int32_t* outPrefixLength, int32_t* outSuffixLength,
                                    Field field, UErrorCode& status) { … }


int32_t ConstantMultiFieldModifier::apply(FormattedStringBuilder &output, int leftIndex, int rightIndex,
                                          UErrorCode &status) const { … }

int32_t ConstantMultiFieldModifier::getPrefixLength() const { … }

int32_t ConstantMultiFieldModifier::getCodePointCount() const { … }

bool ConstantMultiFieldModifier::isStrong() const { … }

bool ConstantMultiFieldModifier::containsField(Field field) const { … }

void ConstantMultiFieldModifier::getParameters(Parameters& output) const { … }

bool ConstantMultiFieldModifier::semanticallyEquivalent(const Modifier& other) const { … }


CurrencySpacingEnabledModifier::CurrencySpacingEnabledModifier(const FormattedStringBuilder &prefix,
                                                               const FormattedStringBuilder &suffix,
                                                               bool overwrite,
                                                               bool strong,
                                                               const DecimalFormatSymbols &symbols,
                                                               UErrorCode &status)
        : … { … }

int32_t CurrencySpacingEnabledModifier::apply(FormattedStringBuilder &output, int leftIndex, int rightIndex,
                                              UErrorCode &status) const { … }

int32_t
CurrencySpacingEnabledModifier::applyCurrencySpacing(FormattedStringBuilder &output, int32_t prefixStart,
                                                     int32_t prefixLen, int32_t suffixStart,
                                                     int32_t suffixLen,
                                                     const DecimalFormatSymbols &symbols,
                                                     UErrorCode &status) { … }

int32_t
CurrencySpacingEnabledModifier::applyCurrencySpacingAffix(FormattedStringBuilder &output, int32_t index,
                                                          EAffix affix,
                                                          const DecimalFormatSymbols &symbols,
                                                          UErrorCode &status) { … }

UnicodeSet
CurrencySpacingEnabledModifier::getUnicodeSet(const DecimalFormatSymbols &symbols, EPosition position,
                                              EAffix affix, UErrorCode &status) { … }

UnicodeString
CurrencySpacingEnabledModifier::getInsertString(const DecimalFormatSymbols &symbols, EAffix affix,
                                                UErrorCode &status) { … }

#endif /* #if !UCONFIG_NO_FORMATTING */