[apple/icu.git] / icuSources / 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"

using namespace icu;
using namespace icu::number;
using namespace icu::number::impl;

namespace {

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

// 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 = U_INITONCE_INITIALIZER;

UnicodeSet *UNISET_DIGIT = nullptr;
UnicodeSet *UNISET_NOTS = nullptr;

UBool U_CALLCONV cleanupDefaultCurrencySpacing() {
    delete UNISET_DIGIT;
    UNISET_DIGIT = nullptr;
    delete UNISET_NOTS;
    UNISET_NOTS = nullptr;
    gDefaultCurrencySpacingInitOnce.reset();
    return TRUE;
}

void U_CALLCONV initDefaultCurrencySpacing(UErrorCode &status) {
    ucln_i18n_registerCleanup(UCLN_I18N_CURRENCY_SPACING, cleanupDefaultCurrencySpacing);
    UNISET_DIGIT = new UnicodeSet(UnicodeString(u"[:digit:]"), status);
    UNISET_NOTS = new UnicodeSet(UnicodeString(u"[:^S:]"), status);
    if (UNISET_DIGIT == nullptr || UNISET_NOTS == nullptr) {
        status = U_MEMORY_ALLOCATION_ERROR;
        return;
    }
    UNISET_DIGIT->freeze();
    UNISET_NOTS->freeze();
}

}  // namespace


Modifier::~Modifier() = default;

Modifier::Parameters::Parameters()
        : obj(nullptr) {}

Modifier::Parameters::Parameters(
    const ModifierStore* _obj, int8_t _signum, StandardPlural::Form _plural)
        : obj(_obj), signum(_signum), plural(_plural) {}

ModifierStore::~ModifierStore() = default;

AdoptingModifierStore::~AdoptingModifierStore()  {
    for (const Modifier *mod : mods) {
        delete mod;
    }
}


int32_t ConstantAffixModifier::apply(NumberStringBuilder &output, int leftIndex, int rightIndex,
                                     UErrorCode &status) const {
    // Insert the suffix first since inserting the prefix will change the rightIndex
    int length = output.insert(rightIndex, fSuffix, fField, status);
    length += output.insert(leftIndex, fPrefix, fField, status);
    return length;
}

int32_t ConstantAffixModifier::getPrefixLength() const {
    return fPrefix.length();
}

int32_t ConstantAffixModifier::getCodePointCount() const {
    return fPrefix.countChar32() + fSuffix.countChar32();
}

bool ConstantAffixModifier::isStrong() const {
    return fStrong;
}

bool ConstantAffixModifier::containsField(UNumberFormatFields field) const {
    (void)field;
    // This method is not currently used.
    UPRV_UNREACHABLE;
}

void ConstantAffixModifier::getParameters(Parameters& output) const {
    (void)output;
    // This method is not currently used.
    UPRV_UNREACHABLE;
}

bool ConstantAffixModifier::semanticallyEquivalent(const Modifier& other) const {
    auto* _other = dynamic_cast<const ConstantAffixModifier*>(&other);
    if (_other == nullptr) {
        return false;
    }
    return fPrefix == _other->fPrefix
        && fSuffix == _other->fSuffix
        && fField == _other->fField
        && fStrong == _other->fStrong;
}


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

SimpleModifier::SimpleModifier(const SimpleFormatter &simpleFormatter, Field field, bool strong,
                               const Modifier::Parameters parameters)
        : fCompiledPattern(simpleFormatter.compiledPattern), fField(field), fStrong(strong),
          fParameters(parameters) {
    int32_t argLimit = SimpleFormatter::getArgumentLimit(
            fCompiledPattern.getBuffer(), fCompiledPattern.length());
    if (argLimit == 0) {
        // No arguments in compiled pattern
        fPrefixLength = fCompiledPattern.charAt(1) - ARG_NUM_LIMIT;
        U_ASSERT(2 + fPrefixLength == fCompiledPattern.length());
        // Set suffixOffset = -1 to indicate no arguments in compiled pattern.
        fSuffixOffset = -1;
        fSuffixLength = 0;
    } else {
        U_ASSERT(argLimit == 1);
        if (fCompiledPattern.charAt(1) != 0) {
            // Found prefix
            fPrefixLength = fCompiledPattern.charAt(1) - ARG_NUM_LIMIT;
            fSuffixOffset = 3 + fPrefixLength;
        } else {
            // No prefix
            fPrefixLength = 0;
            fSuffixOffset = 2;
        }
        if (3 + fPrefixLength < fCompiledPattern.length()) {
            // Found suffix
            fSuffixLength = fCompiledPattern.charAt(fSuffixOffset) - ARG_NUM_LIMIT;
        } else {
            // No suffix
            fSuffixLength = 0;
        }
    }
}

SimpleModifier::SimpleModifier()
        : fField(UNUM_FIELD_COUNT), fStrong(false), fPrefixLength(0), fSuffixLength(0) {
}

int32_t SimpleModifier::apply(NumberStringBuilder &output, int leftIndex, int rightIndex,
                              UErrorCode &status) const {
    return formatAsPrefixSuffix(output, leftIndex, rightIndex, status);
}

int32_t SimpleModifier::getPrefixLength() const {
    return fPrefixLength;
}

int32_t SimpleModifier::getCodePointCount() const {
    int32_t count = 0;
    if (fPrefixLength > 0) {
        count += fCompiledPattern.countChar32(2, fPrefixLength);
    }
    if (fSuffixLength > 0) {
        count += fCompiledPattern.countChar32(1 + fSuffixOffset, fSuffixLength);
    }
    return count;
}

bool SimpleModifier::isStrong() const {
    return fStrong;
}

bool SimpleModifier::containsField(UNumberFormatFields field) const {
    (void)field;
    // This method is not currently used.
    UPRV_UNREACHABLE;
}

void SimpleModifier::getParameters(Parameters& output) const {
    output = fParameters;
}

bool SimpleModifier::semanticallyEquivalent(const Modifier& other) const {
    auto* _other = dynamic_cast<const SimpleModifier*>(&other);
    if (_other == nullptr) {
        return false;
    }
    if (fParameters.obj != nullptr) {
        return fParameters.obj == _other->fParameters.obj;
    }
    return fCompiledPattern == _other->fCompiledPattern
        && fField == _other->fField
        && fStrong == _other->fStrong;
}


int32_t
SimpleModifier::formatAsPrefixSuffix(NumberStringBuilder &result, int32_t startIndex, int32_t endIndex,
                                     UErrorCode &status) const {
    if (fSuffixOffset == -1 && fPrefixLength + fSuffixLength > 0) {
        // There is no argument for the inner number; overwrite the entire segment with our string.
        return result.splice(startIndex, endIndex, fCompiledPattern, 2, 2 + fPrefixLength, fField, status);
    } else {
        if (fPrefixLength > 0) {
            result.insert(startIndex, fCompiledPattern, 2, 2 + fPrefixLength, fField, status);
        }
        if (fSuffixLength > 0) {
            result.insert(
                    endIndex + fPrefixLength,
                    fCompiledPattern,
                    1 + fSuffixOffset,
                    1 + fSuffixOffset + fSuffixLength,
                    fField,
                    status);
        }
        return fPrefixLength + fSuffixLength;
    }
}


int32_t
SimpleModifier::formatTwoArgPattern(const SimpleFormatter& compiled, NumberStringBuilder& result,
                                    int32_t index, int32_t* outPrefixLength, int32_t* outSuffixLength,
                                    Field field, UErrorCode& status) {
    const UnicodeString& compiledPattern = compiled.compiledPattern;
    int32_t argLimit = SimpleFormatter::getArgumentLimit(
            compiledPattern.getBuffer(), compiledPattern.length());
    if (argLimit != 2) {
        status = U_INTERNAL_PROGRAM_ERROR;
        return 0;
    }
    int32_t offset = 1; // offset into compiledPattern
    int32_t length = 0; // chars added to result

    int32_t prefixLength = compiledPattern.charAt(offset);
    offset++;
    if (prefixLength < ARG_NUM_LIMIT) {
        // No prefix
        prefixLength = 0;
    } else {
        prefixLength -= ARG_NUM_LIMIT;
        result.insert(index + length, compiledPattern, offset, offset + prefixLength, field, status);
        offset += prefixLength;
        length += prefixLength;
        offset++;
    }

    int32_t infixLength = compiledPattern.charAt(offset);
    offset++;
    if (infixLength < ARG_NUM_LIMIT) {
        // No infix
        infixLength = 0;
    } else {
        infixLength -= ARG_NUM_LIMIT;
        result.insert(index + length, compiledPattern, offset, offset + infixLength, field, status);
        offset += infixLength;
        length += infixLength;
        offset++;
    }

    int32_t suffixLength;
    if (offset == compiledPattern.length()) {
        // No suffix
        suffixLength = 0;
    } else {
        suffixLength = compiledPattern.charAt(offset) -  ARG_NUM_LIMIT;
        offset++;
        result.insert(index + length, compiledPattern, offset, offset + suffixLength, field, status);
        length += suffixLength;
    }

    *outPrefixLength = prefixLength;
    *outSuffixLength = suffixLength;

    return length;
}


int32_t ConstantMultiFieldModifier::apply(NumberStringBuilder &output, int leftIndex, int rightIndex,
                                          UErrorCode &status) const {
    int32_t length = output.insert(leftIndex, fPrefix, status);
    if (fOverwrite) {
        length += output.splice(
            leftIndex + length,
            rightIndex + length,
            UnicodeString(), 0, 0,
            UNUM_FIELD_COUNT, status);
    }
    length += output.insert(rightIndex + length, fSuffix, status);
    return length;
}

int32_t ConstantMultiFieldModifier::getPrefixLength() const {
    return fPrefix.length();
}

int32_t ConstantMultiFieldModifier::getCodePointCount() const {
    return fPrefix.codePointCount() + fSuffix.codePointCount();
}

bool ConstantMultiFieldModifier::isStrong() const {
    return fStrong;
}

bool ConstantMultiFieldModifier::containsField(UNumberFormatFields field) const {
    return fPrefix.containsField(field) || fSuffix.containsField(field);
}

void ConstantMultiFieldModifier::getParameters(Parameters& output) const {
    output = fParameters;
}

bool ConstantMultiFieldModifier::semanticallyEquivalent(const Modifier& other) const {
    auto* _other = dynamic_cast<const ConstantMultiFieldModifier*>(&other);
    if (_other == nullptr) {
        return false;
    }
    if (fParameters.obj != nullptr) {
        return fParameters.obj == _other->fParameters.obj;
    }
    return fPrefix.contentEquals(_other->fPrefix)
        && fSuffix.contentEquals(_other->fSuffix)
        && fOverwrite == _other->fOverwrite
        && fStrong == _other->fStrong;
}


CurrencySpacingEnabledModifier::CurrencySpacingEnabledModifier(const NumberStringBuilder &prefix,
                                                               const NumberStringBuilder &suffix,
                                                               bool overwrite,
                                                               bool strong,
                                                               const DecimalFormatSymbols &symbols,
                                                               UErrorCode &status)
        : ConstantMultiFieldModifier(prefix, suffix, overwrite, strong) {
    // Check for currency spacing. Do not build the UnicodeSets unless there is
    // a currency code point at a boundary.
    if (prefix.length() > 0 && prefix.fieldAt(prefix.length() - 1) == UNUM_CURRENCY_FIELD) {
        int prefixCp = prefix.getLastCodePoint();
        UnicodeSet prefixUnicodeSet = getUnicodeSet(symbols, IN_CURRENCY, PREFIX, status);
        if (prefixUnicodeSet.contains(prefixCp)) {
            fAfterPrefixUnicodeSet = getUnicodeSet(symbols, IN_NUMBER, PREFIX, status);
            fAfterPrefixUnicodeSet.freeze();
            fAfterPrefixInsert = getInsertString(symbols, PREFIX, status);
        } else {
            fAfterPrefixUnicodeSet.setToBogus();
            fAfterPrefixInsert.setToBogus();
        }
    } else {
        fAfterPrefixUnicodeSet.setToBogus();
        fAfterPrefixInsert.setToBogus();
    }
    if (suffix.length() > 0 && suffix.fieldAt(0) == UNUM_CURRENCY_FIELD) {
        int suffixCp = suffix.getLastCodePoint();
        UnicodeSet suffixUnicodeSet = getUnicodeSet(symbols, IN_CURRENCY, SUFFIX, status);
        if (suffixUnicodeSet.contains(suffixCp)) {
            fBeforeSuffixUnicodeSet = getUnicodeSet(symbols, IN_NUMBER, SUFFIX, status);
            fBeforeSuffixUnicodeSet.freeze();
            fBeforeSuffixInsert = getInsertString(symbols, SUFFIX, status);
        } else {
            fBeforeSuffixUnicodeSet.setToBogus();
            fBeforeSuffixInsert.setToBogus();
        }
    } else {
        fBeforeSuffixUnicodeSet.setToBogus();
        fBeforeSuffixInsert.setToBogus();
    }
}

int32_t CurrencySpacingEnabledModifier::apply(NumberStringBuilder &output, int leftIndex, int rightIndex,
                                              UErrorCode &status) const {
    // Currency spacing logic
    int length = 0;
    if (rightIndex - leftIndex > 0 && !fAfterPrefixUnicodeSet.isBogus() &&
        fAfterPrefixUnicodeSet.contains(output.codePointAt(leftIndex))) {
        // TODO: Should we use the CURRENCY field here?
        length += output.insert(leftIndex, fAfterPrefixInsert, UNUM_FIELD_COUNT, status);
    }
    if (rightIndex - leftIndex > 0 && !fBeforeSuffixUnicodeSet.isBogus() &&
        fBeforeSuffixUnicodeSet.contains(output.codePointBefore(rightIndex))) {
        // TODO: Should we use the CURRENCY field here?
        length += output.insert(rightIndex + length, fBeforeSuffixInsert, UNUM_FIELD_COUNT, status);
    }

    // Call super for the remaining logic
    length += ConstantMultiFieldModifier::apply(output, leftIndex, rightIndex + length, status);
    return length;
}

int32_t
CurrencySpacingEnabledModifier::applyCurrencySpacing(NumberStringBuilder &output, int32_t prefixStart,
                                                     int32_t prefixLen, int32_t suffixStart,
                                                     int32_t suffixLen,
                                                     const DecimalFormatSymbols &symbols,
                                                     UErrorCode &status) {
    int length = 0;
    bool hasPrefix = (prefixLen > 0);
    bool hasSuffix = (suffixLen > 0);
    bool hasNumber = (suffixStart - prefixStart - prefixLen > 0); // could be empty string
    if (hasPrefix && hasNumber) {
        length += applyCurrencySpacingAffix(output, prefixStart + prefixLen, PREFIX, symbols, status);
    }
    if (hasSuffix && hasNumber) {
        length += applyCurrencySpacingAffix(output, suffixStart + length, SUFFIX, symbols, status);
    }
    return length;
}

int32_t
CurrencySpacingEnabledModifier::applyCurrencySpacingAffix(NumberStringBuilder &output, int32_t index,
                                                          EAffix affix,
                                                          const DecimalFormatSymbols &symbols,
                                                          UErrorCode &status) {
    // NOTE: For prefix, output.fieldAt(index-1) gets the last field type in the prefix.
    // This works even if the last code point in the prefix is 2 code units because the
    // field value gets populated to both indices in the field array.
    Field affixField = (affix == PREFIX) ? output.fieldAt(index - 1) : output.fieldAt(index);
    if (affixField != UNUM_CURRENCY_FIELD) {
        return 0;
    }
    int affixCp = (affix == PREFIX) ? output.codePointBefore(index) : output.codePointAt(index);
    UnicodeSet affixUniset = getUnicodeSet(symbols, IN_CURRENCY, affix, status);
    if (!affixUniset.contains(affixCp)) {
        return 0;
    }
    int numberCp = (affix == PREFIX) ? output.codePointAt(index) : output.codePointBefore(index);
    UnicodeSet numberUniset = getUnicodeSet(symbols, IN_NUMBER, affix, status);
    if (!numberUniset.contains(numberCp)) {
        return 0;
    }
    UnicodeString spacingString = getInsertString(symbols, affix, status);

    // NOTE: This next line *inserts* the spacing string, triggering an arraycopy.
    // It would be more efficient if this could be done before affixes were attached,
    // so that it could be prepended/appended instead of inserted.
    // However, the build code path is more efficient, and this is the most natural
    // place to put currency spacing in the non-build code path.
    // TODO: Should we use the CURRENCY field here?
    return output.insert(index, spacingString, UNUM_FIELD_COUNT, status);
}

UnicodeSet
CurrencySpacingEnabledModifier::getUnicodeSet(const DecimalFormatSymbols &symbols, EPosition position,
                                              EAffix affix, UErrorCode &status) {
    // Ensure the static defaults are initialized:
    umtx_initOnce(gDefaultCurrencySpacingInitOnce, &initDefaultCurrencySpacing, status);
    if (U_FAILURE(status)) {
        return UnicodeSet();
    }

    const UnicodeString& pattern = symbols.getPatternForCurrencySpacing(
            position == IN_CURRENCY ? UNUM_CURRENCY_MATCH : UNUM_CURRENCY_SURROUNDING_MATCH,
            affix == SUFFIX,
            status);
    if (pattern.compare(u"[:digit:]", -1) == 0) {
        return *UNISET_DIGIT;
    } else if (pattern.compare(u"[:^S:]", -1) == 0) {
        return *UNISET_NOTS;
    } else {
        return UnicodeSet(pattern, status);
    }
}

UnicodeString
CurrencySpacingEnabledModifier::getInsertString(const DecimalFormatSymbols &symbols, EAffix affix,
                                                UErrorCode &status) {
    return symbols.getPatternForCurrencySpacing(UNUM_CURRENCY_INSERT, affix == SUFFIX, status);
}

#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
0f5d89e8 A	1	// © 2017 and later: Unicode, Inc. and others.
	2	// License & terms of use: http://www.unicode.org/copyright.html
	3
	4	#include "unicode/utypes.h"
	5
	6	#if !UCONFIG_NO_FORMATTING
	7
	8	#include "umutex.h"
	9	#include "ucln_cmn.h"
	10	#include "ucln_in.h"
	11	#include "number_modifiers.h"
	12
	13	using namespace icu;
	14	using namespace icu::number;
	15	using namespace icu::number::impl;
	16
	17	namespace {
	18
	19	// TODO: This is copied from simpleformatter.cpp
	20	const int32_t ARG_NUM_LIMIT = 0x100;
	21
	22	// These are the default currency spacing UnicodeSets in CLDR.
	23	// Pre-compute them for performance.
	24	// The Java unit test testCurrencySpacingPatternStability() will start failing if these change in CLDR.
	25	icu::UInitOnce gDefaultCurrencySpacingInitOnce = U_INITONCE_INITIALIZER;
	26
	27	UnicodeSet *UNISET_DIGIT = nullptr;
	28	UnicodeSet *UNISET_NOTS = nullptr;
	29
	30	UBool U_CALLCONV cleanupDefaultCurrencySpacing() {
	31	delete UNISET_DIGIT;
	32	UNISET_DIGIT = nullptr;
	33	delete UNISET_NOTS;
	34	UNISET_NOTS = nullptr;
	35	gDefaultCurrencySpacingInitOnce.reset();
	36	return TRUE;
	37	}
	38
	39	void U_CALLCONV initDefaultCurrencySpacing(UErrorCode &status) {
	40	ucln_i18n_registerCleanup(UCLN_I18N_CURRENCY_SPACING, cleanupDefaultCurrencySpacing);
	41	UNISET_DIGIT = new UnicodeSet(UnicodeString(u"[:digit:]"), status);
	42	UNISET_NOTS = new UnicodeSet(UnicodeString(u"[:^S:]"), status);
	43	if (UNISET_DIGIT == nullptr \|\| UNISET_NOTS == nullptr) {
	44	status = U_MEMORY_ALLOCATION_ERROR;
	45	return;
	46	}
	47	UNISET_DIGIT->freeze();
	48	UNISET_NOTS->freeze();
	49	}
	50
	51	} // namespace
	52
	53
	54	Modifier::~Modifier() = default;
	55
3d1f044b A	56	Modifier::Parameters::Parameters()
	57	: obj(nullptr) {}
	58
	59	Modifier::Parameters::Parameters(
	60	const ModifierStore* _obj, int8_t _signum, StandardPlural::Form _plural)
	61	: obj(_obj), signum(_signum), plural(_plural) {}
	62
	63	ModifierStore::~ModifierStore() = default;
	64
	65	AdoptingModifierStore::~AdoptingModifierStore() {
	66	for (const Modifier *mod : mods) {
	67	delete mod;
	68	}
	69	}
	70
0f5d89e8 A	71
	72	int32_t ConstantAffixModifier::apply(NumberStringBuilder &output, int leftIndex, int rightIndex,
	73	UErrorCode &status) const {
	74	// Insert the suffix first since inserting the prefix will change the rightIndex
	75	int length = output.insert(rightIndex, fSuffix, fField, status);
	76	length += output.insert(leftIndex, fPrefix, fField, status);
	77	return length;
	78	}
	79
3d1f044b	80	int32_t ConstantAffixModifier::getPrefixLength() const {
0f5d89e8 A	81	return fPrefix.length();
	82	}
	83
3d1f044b	84	int32_t ConstantAffixModifier::getCodePointCount() const {
0f5d89e8 A	85	return fPrefix.countChar32() + fSuffix.countChar32();
	86	}
	87
	88	bool ConstantAffixModifier::isStrong() const {
	89	return fStrong;
	90	}
	91
3d1f044b A	92	bool ConstantAffixModifier::containsField(UNumberFormatFields field) const {
	93	(void)field;
	94	// This method is not currently used.
	95	UPRV_UNREACHABLE;
	96	}
	97
	98	void ConstantAffixModifier::getParameters(Parameters& output) const {
	99	(void)output;
	100	// This method is not currently used.
	101	UPRV_UNREACHABLE;
	102	}
	103
	104	bool ConstantAffixModifier::semanticallyEquivalent(const Modifier& other) const {
	105	auto* _other = dynamic_cast<const ConstantAffixModifier*>(&other);
	106	if (_other == nullptr) {
	107	return false;
	108	}
	109	return fPrefix == _other->fPrefix
	110	&& fSuffix == _other->fSuffix
	111	&& fField == _other->fField
	112	&& fStrong == _other->fStrong;
	113	}
	114
	115
0f5d89e8	116	SimpleModifier::SimpleModifier(const SimpleFormatter &simpleFormatter, Field field, bool strong)
3d1f044b A	117	: SimpleModifier(simpleFormatter, field, strong, {}) {}
	118
	119	SimpleModifier::SimpleModifier(const SimpleFormatter &simpleFormatter, Field field, bool strong,
	120	const Modifier::Parameters parameters)
	121	: fCompiledPattern(simpleFormatter.compiledPattern), fField(field), fStrong(strong),
	122	fParameters(parameters) {
0f5d89e8 A	123	int32_t argLimit = SimpleFormatter::getArgumentLimit(
	124	fCompiledPattern.getBuffer(), fCompiledPattern.length());
	125	if (argLimit == 0) {
	126	// No arguments in compiled pattern
	127	fPrefixLength = fCompiledPattern.charAt(1) - ARG_NUM_LIMIT;
	128	U_ASSERT(2 + fPrefixLength == fCompiledPattern.length());
	129	// Set suffixOffset = -1 to indicate no arguments in compiled pattern.
	130	fSuffixOffset = -1;
	131	fSuffixLength = 0;
	132	} else {
	133	U_ASSERT(argLimit == 1);
	134	if (fCompiledPattern.charAt(1) != 0) {
3d1f044b	135	// Found prefix
0f5d89e8 A	136	fPrefixLength = fCompiledPattern.charAt(1) - ARG_NUM_LIMIT;
	137	fSuffixOffset = 3 + fPrefixLength;
	138	} else {
3d1f044b	139	// No prefix
0f5d89e8 A	140	fPrefixLength = 0;
	141	fSuffixOffset = 2;
	142	}
	143	if (3 + fPrefixLength < fCompiledPattern.length()) {
3d1f044b	144	// Found suffix
0f5d89e8 A	145	fSuffixLength = fCompiledPattern.charAt(fSuffixOffset) - ARG_NUM_LIMIT;
0f5d89e8 A	146	} else {
3d1f044b	147	// No suffix
0f5d89e8 A	148	fSuffixLength = 0;
	149	}
	150	}
	151	}
	152
	153	SimpleModifier::SimpleModifier()
	154	: fField(UNUM_FIELD_COUNT), fStrong(false), fPrefixLength(0), fSuffixLength(0) {
	155	}
	156
	157	int32_t SimpleModifier::apply(NumberStringBuilder &output, int leftIndex, int rightIndex,
	158	UErrorCode &status) const {
3d1f044b	159	return formatAsPrefixSuffix(output, leftIndex, rightIndex, status);
0f5d89e8 A	160	}
0f5d89e8 A	161
3d1f044b	162	int32_t SimpleModifier::getPrefixLength() const {
0f5d89e8 A	163	return fPrefixLength;
	164	}
	165
3d1f044b	166	int32_t SimpleModifier::getCodePointCount() const {
0f5d89e8 A	167	int32_t count = 0;
	168	if (fPrefixLength > 0) {
	169	count += fCompiledPattern.countChar32(2, fPrefixLength);
	170	}
	171	if (fSuffixLength > 0) {
	172	count += fCompiledPattern.countChar32(1 + fSuffixOffset, fSuffixLength);
	173	}
	174	return count;
	175	}
	176
	177	bool SimpleModifier::isStrong() const {
	178	return fStrong;
	179	}
	180
3d1f044b A	181	bool SimpleModifier::containsField(UNumberFormatFields field) const {
	182	(void)field;
	183	// This method is not currently used.
	184	UPRV_UNREACHABLE;
	185	}
	186
	187	void SimpleModifier::getParameters(Parameters& output) const {
	188	output = fParameters;
	189	}
	190
	191	bool SimpleModifier::semanticallyEquivalent(const Modifier& other) const {
	192	auto* _other = dynamic_cast<const SimpleModifier*>(&other);
	193	if (_other == nullptr) {
	194	return false;
	195	}
	196	if (fParameters.obj != nullptr) {
	197	return fParameters.obj == _other->fParameters.obj;
	198	}
	199	return fCompiledPattern == _other->fCompiledPattern
	200	&& fField == _other->fField
	201	&& fStrong == _other->fStrong;
	202	}
	203
	204
0f5d89e8 A	205	int32_t
0f5d89e8 A	206	SimpleModifier::formatAsPrefixSuffix(NumberStringBuilder &result, int32_t startIndex, int32_t endIndex,
3d1f044b A	207	UErrorCode &status) const {
3d1f044b A	208	if (fSuffixOffset == -1 && fPrefixLength + fSuffixLength > 0) {
0f5d89e8	209	// There is no argument for the inner number; overwrite the entire segment with our string.
3d1f044b	210	return result.splice(startIndex, endIndex, fCompiledPattern, 2, 2 + fPrefixLength, fField, status);
0f5d89e8 A	211	} else {
0f5d89e8 A	212	if (fPrefixLength > 0) {
3d1f044b	213	result.insert(startIndex, fCompiledPattern, 2, 2 + fPrefixLength, fField, status);
0f5d89e8 A	214	}
	215	if (fSuffixLength > 0) {
	216	result.insert(
	217	endIndex + fPrefixLength,
	218	fCompiledPattern,
	219	1 + fSuffixOffset,
	220	1 + fSuffixOffset + fSuffixLength,
3d1f044b	221	fField,
0f5d89e8 A	222	status);
	223	}
	224	return fPrefixLength + fSuffixLength;
	225	}
	226	}
	227
3d1f044b A	228
	229	int32_t
	230	SimpleModifier::formatTwoArgPattern(const SimpleFormatter& compiled, NumberStringBuilder& result,
	231	int32_t index, int32_t* outPrefixLength, int32_t* outSuffixLength,
	232	Field field, UErrorCode& status) {
	233	const UnicodeString& compiledPattern = compiled.compiledPattern;
	234	int32_t argLimit = SimpleFormatter::getArgumentLimit(
	235	compiledPattern.getBuffer(), compiledPattern.length());
	236	if (argLimit != 2) {
	237	status = U_INTERNAL_PROGRAM_ERROR;
	238	return 0;
	239	}
	240	int32_t offset = 1; // offset into compiledPattern
	241	int32_t length = 0; // chars added to result
	242
	243	int32_t prefixLength = compiledPattern.charAt(offset);
	244	offset++;
	245	if (prefixLength < ARG_NUM_LIMIT) {
	246	// No prefix
	247	prefixLength = 0;
	248	} else {
	249	prefixLength -= ARG_NUM_LIMIT;
	250	result.insert(index + length, compiledPattern, offset, offset + prefixLength, field, status);
	251	offset += prefixLength;
	252	length += prefixLength;
	253	offset++;
	254	}
	255
	256	int32_t infixLength = compiledPattern.charAt(offset);
	257	offset++;
	258	if (infixLength < ARG_NUM_LIMIT) {
	259	// No infix
	260	infixLength = 0;
	261	} else {
	262	infixLength -= ARG_NUM_LIMIT;
	263	result.insert(index + length, compiledPattern, offset, offset + infixLength, field, status);
	264	offset += infixLength;
	265	length += infixLength;
	266	offset++;
	267	}
	268
	269	int32_t suffixLength;
	270	if (offset == compiledPattern.length()) {
	271	// No suffix
	272	suffixLength = 0;
	273	} else {
	274	suffixLength = compiledPattern.charAt(offset) - ARG_NUM_LIMIT;
	275	offset++;
	276	result.insert(index + length, compiledPattern, offset, offset + suffixLength, field, status);
	277	length += suffixLength;
	278	}
	279
	280	*outPrefixLength = prefixLength;
	281	*outSuffixLength = suffixLength;
	282
	283	return length;
	284	}
	285
	286
0f5d89e8 A	287	int32_t ConstantMultiFieldModifier::apply(NumberStringBuilder &output, int leftIndex, int rightIndex,
	288	UErrorCode &status) const {
	289	int32_t length = output.insert(leftIndex, fPrefix, status);
	290	if (fOverwrite) {
	291	length += output.splice(
	292	leftIndex + length,
	293	rightIndex + length,
	294	UnicodeString(), 0, 0,
	295	UNUM_FIELD_COUNT, status);
	296	}
	297	length += output.insert(rightIndex + length, fSuffix, status);
	298	return length;
	299	}
	300
3d1f044b	301	int32_t ConstantMultiFieldModifier::getPrefixLength() const {
0f5d89e8 A	302	return fPrefix.length();
	303	}
	304
3d1f044b	305	int32_t ConstantMultiFieldModifier::getCodePointCount() const {
0f5d89e8 A	306	return fPrefix.codePointCount() + fSuffix.codePointCount();
	307	}
	308
	309	bool ConstantMultiFieldModifier::isStrong() const {
	310	return fStrong;
	311	}
	312
3d1f044b A	313	bool ConstantMultiFieldModifier::containsField(UNumberFormatFields field) const {
	314	return fPrefix.containsField(field) \|\| fSuffix.containsField(field);
	315	}
	316
	317	void ConstantMultiFieldModifier::getParameters(Parameters& output) const {
	318	output = fParameters;
	319	}
	320
	321	bool ConstantMultiFieldModifier::semanticallyEquivalent(const Modifier& other) const {
	322	auto* _other = dynamic_cast<const ConstantMultiFieldModifier*>(&other);
	323	if (_other == nullptr) {
	324	return false;
	325	}
	326	if (fParameters.obj != nullptr) {
	327	return fParameters.obj == _other->fParameters.obj;
	328	}
	329	return fPrefix.contentEquals(_other->fPrefix)
	330	&& fSuffix.contentEquals(_other->fSuffix)
	331	&& fOverwrite == _other->fOverwrite
	332	&& fStrong == _other->fStrong;
	333	}
	334
	335
0f5d89e8 A	336	CurrencySpacingEnabledModifier::CurrencySpacingEnabledModifier(const NumberStringBuilder &prefix,
	337	const NumberStringBuilder &suffix,
	338	bool overwrite,
	339	bool strong,
	340	const DecimalFormatSymbols &symbols,
	341	UErrorCode &status)
	342	: ConstantMultiFieldModifier(prefix, suffix, overwrite, strong) {
	343	// Check for currency spacing. Do not build the UnicodeSets unless there is
	344	// a currency code point at a boundary.
	345	if (prefix.length() > 0 && prefix.fieldAt(prefix.length() - 1) == UNUM_CURRENCY_FIELD) {
	346	int prefixCp = prefix.getLastCodePoint();
	347	UnicodeSet prefixUnicodeSet = getUnicodeSet(symbols, IN_CURRENCY, PREFIX, status);
	348	if (prefixUnicodeSet.contains(prefixCp)) {
	349	fAfterPrefixUnicodeSet = getUnicodeSet(symbols, IN_NUMBER, PREFIX, status);
	350	fAfterPrefixUnicodeSet.freeze();
	351	fAfterPrefixInsert = getInsertString(symbols, PREFIX, status);
	352	} else {
	353	fAfterPrefixUnicodeSet.setToBogus();
	354	fAfterPrefixInsert.setToBogus();
	355	}
	356	} else {
	357	fAfterPrefixUnicodeSet.setToBogus();
	358	fAfterPrefixInsert.setToBogus();
	359	}
	360	if (suffix.length() > 0 && suffix.fieldAt(0) == UNUM_CURRENCY_FIELD) {
	361	int suffixCp = suffix.getLastCodePoint();
	362	UnicodeSet suffixUnicodeSet = getUnicodeSet(symbols, IN_CURRENCY, SUFFIX, status);
	363	if (suffixUnicodeSet.contains(suffixCp)) {
	364	fBeforeSuffixUnicodeSet = getUnicodeSet(symbols, IN_NUMBER, SUFFIX, status);
	365	fBeforeSuffixUnicodeSet.freeze();
	366	fBeforeSuffixInsert = getInsertString(symbols, SUFFIX, status);
	367	} else {
	368	fBeforeSuffixUnicodeSet.setToBogus();
	369	fBeforeSuffixInsert.setToBogus();
	370	}
	371	} else {
	372	fBeforeSuffixUnicodeSet.setToBogus();
	373	fBeforeSuffixInsert.setToBogus();
	374	}
	375	}
	376
	377	int32_t CurrencySpacingEnabledModifier::apply(NumberStringBuilder &output, int leftIndex, int rightIndex,
	378	UErrorCode &status) const {
	379	// Currency spacing logic
	380	int length = 0;
	381	if (rightIndex - leftIndex > 0 && !fAfterPrefixUnicodeSet.isBogus() &&
	382	fAfterPrefixUnicodeSet.contains(output.codePointAt(leftIndex))) {
	383	// TODO: Should we use the CURRENCY field here?
	384	length += output.insert(leftIndex, fAfterPrefixInsert, UNUM_FIELD_COUNT, status);
	385	}
	386	if (rightIndex - leftIndex > 0 && !fBeforeSuffixUnicodeSet.isBogus() &&
	387	fBeforeSuffixUnicodeSet.contains(output.codePointBefore(rightIndex))) {
	388	// TODO: Should we use the CURRENCY field here?
	389	length += output.insert(rightIndex + length, fBeforeSuffixInsert, UNUM_FIELD_COUNT, status);
	390	}
	391
	392	// Call super for the remaining logic
	393	length += ConstantMultiFieldModifier::apply(output, leftIndex, rightIndex + length, status);
	394	return length;
	395	}
	396
	397	int32_t
	398	CurrencySpacingEnabledModifier::applyCurrencySpacing(NumberStringBuilder &output, int32_t prefixStart,
	399	int32_t prefixLen, int32_t suffixStart,
400	int32_t suffixLen,
401	const DecimalFormatSymbols &symbols,
402	UErrorCode &status) {
403	int length = 0;
404	bool hasPrefix = (prefixLen > 0);
405	bool hasSuffix = (suffixLen > 0);
406	bool hasNumber = (suffixStart - prefixStart - prefixLen > 0); // could be empty string
407	if (hasPrefix && hasNumber) {
408	length += applyCurrencySpacingAffix(output, prefixStart + prefixLen, PREFIX, symbols, status);
409	}
410	if (hasSuffix && hasNumber) {
411	length += applyCurrencySpacingAffix(output, suffixStart + length, SUFFIX, symbols, status);
412	}
413	return length;
414	}
415
416	int32_t
417	CurrencySpacingEnabledModifier::applyCurrencySpacingAffix(NumberStringBuilder &output, int32_t index,
418	EAffix affix,
419	const DecimalFormatSymbols &symbols,
420	UErrorCode &status) {
421	// NOTE: For prefix, output.fieldAt(index-1) gets the last field type in the prefix.
422	// This works even if the last code point in the prefix is 2 code units because the
423	// field value gets populated to both indices in the field array.
424	Field affixField = (affix == PREFIX) ? output.fieldAt(index - 1) : output.fieldAt(index);
425	if (affixField != UNUM_CURRENCY_FIELD) {
426	return 0;
427	}
428	int affixCp = (affix == PREFIX) ? output.codePointBefore(index) : output.codePointAt(index);
429	UnicodeSet affixUniset = getUnicodeSet(symbols, IN_CURRENCY, affix, status);
430	if (!affixUniset.contains(affixCp)) {
431	return 0;
432	}
433	int numberCp = (affix == PREFIX) ? output.codePointAt(index) : output.codePointBefore(index);
434	UnicodeSet numberUniset = getUnicodeSet(symbols, IN_NUMBER, affix, status);
435	if (!numberUniset.contains(numberCp)) {
436	return 0;
437	}
438	UnicodeString spacingString = getInsertString(symbols, affix, status);
439
440	// NOTE: This next line inserts the spacing string, triggering an arraycopy.
441	// It would be more efficient if this could be done before affixes were attached,
442	// so that it could be prepended/appended instead of inserted.
443	// However, the build code path is more efficient, and this is the most natural
444	// place to put currency spacing in the non-build code path.
445	// TODO: Should we use the CURRENCY field here?
446	return output.insert(index, spacingString, UNUM_FIELD_COUNT, status);
447	}
448
449	UnicodeSet
450	CurrencySpacingEnabledModifier::getUnicodeSet(const DecimalFormatSymbols &symbols, EPosition position,
451	EAffix affix, UErrorCode &status) {
452	// Ensure the static defaults are initialized:
453	umtx_initOnce(gDefaultCurrencySpacingInitOnce, &initDefaultCurrencySpacing, status);
454	if (U_FAILURE(status)) {
455	return UnicodeSet();
456	}
457
458	const UnicodeString& pattern = symbols.getPatternForCurrencySpacing(
459	position == IN_CURRENCY ? UNUM_CURRENCY_MATCH : UNUM_CURRENCY_SURROUNDING_MATCH,
460	affix == SUFFIX,
461	status);
462	if (pattern.compare(u"[:digit:]", -1) == 0) {
463	return *UNISET_DIGIT;
464	} else if (pattern.compare(u"[:^S:]", -1) == 0) {
465	return *UNISET_NOTS;
466	} else {
467	return UnicodeSet(pattern, status);
468	}
469	}
470
471	UnicodeString
472	CurrencySpacingEnabledModifier::getInsertString(const DecimalFormatSymbols &symbols, EAffix affix,
473	UErrorCode &status) {
474	return symbols.getPatternForCurrencySpacing(UNUM_CURRENCY_INSERT, affix == SUFFIX, status);
475	}
476
477	#endif /* #if !UCONFIG_NO_FORMATTING */