[apple/icu.git] / icuSources / i18n / number_compact.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 "unicode/ustring.h"
#include "unicode/ures.h"
#include "cstring.h"
#include "charstr.h"
#include "resource.h"
#include "number_compact.h"
#include "number_microprops.h"
#include "uresimp.h"

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

namespace {

// A dummy object used when a "0" compact decimal entry is encountered. This is necessary
// in order to prevent falling back to root. Object equality ("==") is intended.
const UChar *USE_FALLBACK = u"<USE FALLBACK>";

/** Produces a string like "NumberElements/latn/patternsShort/decimalFormat". */
void getResourceBundleKey(const char *nsName, CompactStyle compactStyle, CompactType compactType,
                                 CharString &sb, UErrorCode &status) {
    sb.clear();
    sb.append("NumberElements/", status);
    sb.append(nsName, status);
    sb.append(compactStyle == CompactStyle::UNUM_SHORT ? "/patternsShort" : "/patternsLong", status);
    sb.append(compactType == CompactType::TYPE_DECIMAL ? "/decimalFormat" : "/currencyFormat", status);
}

int32_t getIndex(int32_t magnitude, StandardPlural::Form plural) {
    return magnitude * StandardPlural::COUNT + plural;
}

int32_t countZeros(const UChar *patternString, int32_t patternLength) {
    // NOTE: This strategy for computing the number of zeros is a hack for efficiency.
    // It could break if there are any 0s that aren't part of the main pattern.
    int32_t numZeros = 0;
    for (int32_t i = 0; i < patternLength; i++) {
        if (patternString[i] == u'0') {
            numZeros++;
        } else if (numZeros > 0) {
            break; // zeros should always be contiguous
        }
    }
    return numZeros;
}

} // namespace

// NOTE: patterns and multipliers both get zero-initialized.
CompactData::CompactData() : patterns(), multipliers(), largestMagnitude(0), isEmpty(TRUE) {
}

void CompactData::populate(const Locale &locale, const char *nsName, CompactStyle compactStyle,
                           CompactType compactType, UErrorCode &status) {
    CompactDataSink sink(*this);
    LocalUResourceBundlePointer rb(ures_open(nullptr, locale.getName(), &status));
    if (U_FAILURE(status)) { return; }

    bool nsIsLatn = strcmp(nsName, "latn") == 0;
    bool compactIsShort = compactStyle == CompactStyle::UNUM_SHORT;

    // Fall back to latn numbering system and/or short compact style.
    CharString resourceKey;
    getResourceBundleKey(nsName, compactStyle, compactType, resourceKey, status);
    UErrorCode localStatus = U_ZERO_ERROR;
    ures_getAllItemsWithFallback(rb.getAlias(), resourceKey.data(), sink, localStatus);
    if (isEmpty && !nsIsLatn) {
        getResourceBundleKey("latn", compactStyle, compactType, resourceKey, status);
        localStatus = U_ZERO_ERROR;
        ures_getAllItemsWithFallback(rb.getAlias(), resourceKey.data(), sink, localStatus);
    }
    if (isEmpty && !compactIsShort) {
        getResourceBundleKey(nsName, CompactStyle::UNUM_SHORT, compactType, resourceKey, status);
        localStatus = U_ZERO_ERROR;
        ures_getAllItemsWithFallback(rb.getAlias(), resourceKey.data(), sink, localStatus);
    }
    if (isEmpty && !nsIsLatn && !compactIsShort) {
        getResourceBundleKey("latn", CompactStyle::UNUM_SHORT, compactType, resourceKey, status);
        localStatus = U_ZERO_ERROR;
        ures_getAllItemsWithFallback(rb.getAlias(), resourceKey.data(), sink, localStatus);
    }

    // The last fallback should be guaranteed to return data.
    if (isEmpty) {
        status = U_INTERNAL_PROGRAM_ERROR;
    }
}

int32_t CompactData::getMultiplier(int32_t magnitude) const {
    if (magnitude < 0) {
        return 0;
    }
    if (magnitude > largestMagnitude) {
        magnitude = largestMagnitude;
    }
    return multipliers[magnitude];
}

const UChar *CompactData::getPattern(int32_t magnitude, StandardPlural::Form plural) const {
    if (magnitude < 0) {
        return nullptr;
    }
    if (magnitude > largestMagnitude) {
        magnitude = largestMagnitude;
    }
    const UChar *patternString = patterns[getIndex(magnitude, plural)];
    if (patternString == nullptr && plural != StandardPlural::OTHER) {
        // Fall back to "other" plural variant
        patternString = patterns[getIndex(magnitude, StandardPlural::OTHER)];
    }
    if (patternString == USE_FALLBACK) { // == is intended
        // Return null if USE_FALLBACK is present
        patternString = nullptr;
    }
    return patternString;
}

void CompactData::getUniquePatterns(UVector &output, UErrorCode &status) const {
    U_ASSERT(output.isEmpty());
    // NOTE: In C++, this is done more manually with a UVector.
    // In Java, we can take advantage of JDK HashSet.
    for (auto pattern : patterns) {
        if (pattern == nullptr || pattern == USE_FALLBACK) {
            continue;
        }

        // Insert pattern into the UVector if the UVector does not already contain the pattern.
        // Search the UVector from the end since identical patterns are likely to be adjacent.
        for (int32_t i = output.size() - 1; i >= 0; i--) {
            if (u_strcmp(pattern, static_cast<const UChar *>(output[i])) == 0) {
                goto continue_outer;
            }
        }

        // The string was not found; add it to the UVector.
        // ANDY: This requires a const_cast.  Why?
        output.addElement(const_cast<UChar *>(pattern), status);

        continue_outer:
        continue;
    }
}

void CompactData::CompactDataSink::put(const char *key, ResourceValue &value, UBool /*noFallback*/,
                                       UErrorCode &status) {
    // traverse into the table of powers of ten
    ResourceTable powersOfTenTable = value.getTable(status);
    if (U_FAILURE(status)) { return; }
    for (int i3 = 0; powersOfTenTable.getKeyAndValue(i3, key, value); ++i3) {

        // Assumes that the keys are always of the form "10000" where the magnitude is the
        // length of the key minus one.  We expect magnitudes to be less than MAX_DIGITS.
        auto magnitude = static_cast<int8_t> (strlen(key) - 1);
        int8_t multiplier = data.multipliers[magnitude];
        U_ASSERT(magnitude < COMPACT_MAX_DIGITS);

        // Iterate over the plural variants ("one", "other", etc)
        ResourceTable pluralVariantsTable = value.getTable(status);
        if (U_FAILURE(status)) { return; }
        for (int i4 = 0; pluralVariantsTable.getKeyAndValue(i4, key, value); ++i4) {

            // Skip this magnitude/plural if we already have it from a child locale.
            // Note: This also skips USE_FALLBACK entries.
            StandardPlural::Form plural = StandardPlural::fromString(key, status);
            if (U_FAILURE(status)) { return; }
            if (data.patterns[getIndex(magnitude, plural)] != nullptr) {
                continue;
            }

            // The value "0" means that we need to use the default pattern and not fall back
            // to parent locales. Example locale where this is relevant: 'it'.
            int32_t patternLength;
            const UChar *patternString = value.getString(patternLength, status);
            if (U_FAILURE(status)) { return; }
            if (u_strcmp(patternString, u"0") == 0) {
                patternString = USE_FALLBACK;
                patternLength = 0;
            }

            // Save the pattern string. We will parse it lazily.
            data.patterns[getIndex(magnitude, plural)] = patternString;

            // If necessary, compute the multiplier: the difference between the magnitude
            // and the number of zeros in the pattern.
            if (multiplier == 0) {
                int32_t numZeros = countZeros(patternString, patternLength);
                if (numZeros > 0) { // numZeros==0 in certain cases, like Somali "Kun"
                    multiplier = static_cast<int8_t> (numZeros - magnitude - 1);
                }
            }
        }

        // Save the multiplier.
        if (data.multipliers[magnitude] == 0) {
            data.multipliers[magnitude] = multiplier;
            if (magnitude > data.largestMagnitude) {
                data.largestMagnitude = magnitude;
            }
            data.isEmpty = false;
        } else {
            U_ASSERT(data.multipliers[magnitude] == multiplier);
        }
    }
}

///////////////////////////////////////////////////////////
/// END OF CompactData.java; BEGIN CompactNotation.java ///
///////////////////////////////////////////////////////////

CompactHandler::CompactHandler(CompactStyle compactStyle, const Locale &locale, const char *nsName,
                               CompactType compactType, const PluralRules *rules,
                               MutablePatternModifier *buildReference, const MicroPropsGenerator *parent,
                               UErrorCode &status)
        : rules(rules), parent(parent) {
    data.populate(locale, nsName, compactStyle, compactType, status);
    if (buildReference != nullptr) {
        // Safe code path
        precomputeAllModifiers(*buildReference, status);
        safe = TRUE;
    } else {
        // Unsafe code path
        safe = FALSE;
    }
}

CompactHandler::~CompactHandler() {
    for (int32_t i = 0; i < precomputedModsLength; i++) {
        delete precomputedMods[i].mod;
    }
}

void CompactHandler::precomputeAllModifiers(MutablePatternModifier &buildReference, UErrorCode &status) {
    if (U_FAILURE(status)) { return; }

    // Initial capacity of 12 for 0K, 00K, 000K, ...M, ...B, and ...T
    UVector allPatterns(12, status);
    if (U_FAILURE(status)) { return; }
    data.getUniquePatterns(allPatterns, status);
    if (U_FAILURE(status)) { return; }

    // C++ only: ensure that precomputedMods has room.
    precomputedModsLength = allPatterns.size();
    if (precomputedMods.getCapacity() < precomputedModsLength) {
        precomputedMods.resize(allPatterns.size(), status);
        if (U_FAILURE(status)) { return; }
    }

    for (int32_t i = 0; i < precomputedModsLength; i++) {
        auto patternString = static_cast<const UChar *>(allPatterns[i]);
        UnicodeString hello(patternString);
        CompactModInfo &info = precomputedMods[i];
        ParsedPatternInfo patternInfo;
        PatternParser::parseToPatternInfo(UnicodeString(patternString), patternInfo, status);
        if (U_FAILURE(status)) { return; }
        buildReference.setPatternInfo(&patternInfo, UNUM_COMPACT_FIELD);
        info.mod = buildReference.createImmutable(status);
        if (U_FAILURE(status)) { return; }
        info.patternString = patternString;
    }
}

void CompactHandler::processQuantity(DecimalQuantity &quantity, MicroProps &micros,
                                     UErrorCode &status) const {
    parent->processQuantity(quantity, micros, status);
    if (U_FAILURE(status)) { return; }

    // Treat zero as if it had magnitude 0
    int32_t magnitude;
    if (quantity.isZero()) {
        magnitude = 0;
        micros.rounder.apply(quantity, status);
    } else {
        // TODO: Revisit chooseMultiplierAndApply
        int32_t multiplier = micros.rounder.chooseMultiplierAndApply(quantity, data, status);
        magnitude = quantity.isZero() ? 0 : quantity.getMagnitude();
        magnitude -= multiplier;
    }

    StandardPlural::Form plural = utils::getStandardPlural(rules, quantity);
    const UChar *patternString = data.getPattern(magnitude, plural);
    if (patternString == nullptr) {
        // Use the default (non-compact) modifier.
        // No need to take any action.
    } else if (safe) {
        // Safe code path.
        // Java uses a hash set here for O(1) lookup.  C++ uses a linear search.
        // TODO: Benchmark this and maybe change to a binary search or hash table.
        int32_t i = 0;
        for (; i < precomputedModsLength; i++) {
            const CompactModInfo &info = precomputedMods[i];
            if (u_strcmp(patternString, info.patternString) == 0) {
                info.mod->applyToMicros(micros, quantity, status);
                break;
            }
        }
        // It should be guaranteed that we found the entry.
        U_ASSERT(i < precomputedModsLength);
    } else {
        // Unsafe code path.
        // Overwrite the PatternInfo in the existing modMiddle.
        // C++ Note: Use unsafePatternInfo for proper lifecycle.
        ParsedPatternInfo &patternInfo = const_cast<CompactHandler *>(this)->unsafePatternInfo;
        PatternParser::parseToPatternInfo(UnicodeString(patternString), patternInfo, status);
        static_cast<MutablePatternModifier*>(const_cast<Modifier*>(micros.modMiddle))
            ->setPatternInfo(&patternInfo, UNUM_COMPACT_FIELD);
    }

    // We already performed rounding. Do not perform it again.
    micros.rounder = RoundingImpl::passThrough();
}

#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 "unicode/ustring.h"
	9	#include "unicode/ures.h"
	10	#include "cstring.h"
	11	#include "charstr.h"
	12	#include "resource.h"
	13	#include "number_compact.h"
	14	#include "number_microprops.h"
	15	#include "uresimp.h"
	16
	17	using namespace icu;
	18	using namespace icu::number;
	19	using namespace icu::number::impl;
	20
	21	namespace {
	22
	23	// A dummy object used when a "0" compact decimal entry is encountered. This is necessary
	24	// in order to prevent falling back to root. Object equality ("==") is intended.
	25	const UChar *USE_FALLBACK = u"<USE FALLBACK>";
	26
	27	/** Produces a string like "NumberElements/latn/patternsShort/decimalFormat". */
	28	void getResourceBundleKey(const char *nsName, CompactStyle compactStyle, CompactType compactType,
	29	CharString &sb, UErrorCode &status) {
	30	sb.clear();
	31	sb.append("NumberElements/", status);
	32	sb.append(nsName, status);
	33	sb.append(compactStyle == CompactStyle::UNUM_SHORT ? "/patternsShort" : "/patternsLong", status);
	34	sb.append(compactType == CompactType::TYPE_DECIMAL ? "/decimalFormat" : "/currencyFormat", status);
	35	}
	36
	37	int32_t getIndex(int32_t magnitude, StandardPlural::Form plural) {
	38	return magnitude * StandardPlural::COUNT + plural;
	39	}
	40
	41	int32_t countZeros(const UChar *patternString, int32_t patternLength) {
	42	// NOTE: This strategy for computing the number of zeros is a hack for efficiency.
	43	// It could break if there are any 0s that aren't part of the main pattern.
	44	int32_t numZeros = 0;
	45	for (int32_t i = 0; i < patternLength; i++) {
	46	if (patternString[i] == u'0') {
	47	numZeros++;
	48	} else if (numZeros > 0) {
	49	break; // zeros should always be contiguous
	50	}
	51	}
	52	return numZeros;
	53	}
	54
	55	} // namespace
	56
	57	// NOTE: patterns and multipliers both get zero-initialized.
	58	CompactData::CompactData() : patterns(), multipliers(), largestMagnitude(0), isEmpty(TRUE) {
	59	}
	60
	61	void CompactData::populate(const Locale &locale, const char *nsName, CompactStyle compactStyle,
	62	CompactType compactType, UErrorCode &status) {
	63	CompactDataSink sink(*this);
	64	LocalUResourceBundlePointer rb(ures_open(nullptr, locale.getName(), &status));
65	if (U_FAILURE(status)) { return; }
66
67	bool nsIsLatn = strcmp(nsName, "latn") == 0;
68	bool compactIsShort = compactStyle == CompactStyle::UNUM_SHORT;
69
70	// Fall back to latn numbering system and/or short compact style.
71	CharString resourceKey;
72	getResourceBundleKey(nsName, compactStyle, compactType, resourceKey, status);
73	UErrorCode localStatus = U_ZERO_ERROR;
74	ures_getAllItemsWithFallback(rb.getAlias(), resourceKey.data(), sink, localStatus);
75	if (isEmpty && !nsIsLatn) {
76	getResourceBundleKey("latn", compactStyle, compactType, resourceKey, status);
77	localStatus = U_ZERO_ERROR;
78	ures_getAllItemsWithFallback(rb.getAlias(), resourceKey.data(), sink, localStatus);
79	}
80	if (isEmpty && !compactIsShort) {
81	getResourceBundleKey(nsName, CompactStyle::UNUM_SHORT, compactType, resourceKey, status);
82	localStatus = U_ZERO_ERROR;
83	ures_getAllItemsWithFallback(rb.getAlias(), resourceKey.data(), sink, localStatus);
84	}
85	if (isEmpty && !nsIsLatn && !compactIsShort) {
86	getResourceBundleKey("latn", CompactStyle::UNUM_SHORT, compactType, resourceKey, status);
87	localStatus = U_ZERO_ERROR;
88	ures_getAllItemsWithFallback(rb.getAlias(), resourceKey.data(), sink, localStatus);
89	}
90
91	// The last fallback should be guaranteed to return data.
92	if (isEmpty) {
93	status = U_INTERNAL_PROGRAM_ERROR;
94	}
95	}
96
97	int32_t CompactData::getMultiplier(int32_t magnitude) const {
98	if (magnitude < 0) {
99	return 0;
100	}
101	if (magnitude > largestMagnitude) {
102	magnitude = largestMagnitude;
103	}
104	return multipliers[magnitude];
105	}
106
107	const UChar *CompactData::getPattern(int32_t magnitude, StandardPlural::Form plural) const {
108	if (magnitude < 0) {
109	return nullptr;
110	}
111	if (magnitude > largestMagnitude) {
112	magnitude = largestMagnitude;
113	}
114	const UChar *patternString = patterns[getIndex(magnitude, plural)];
115	if (patternString == nullptr && plural != StandardPlural::OTHER) {
116	// Fall back to "other" plural variant
117	patternString = patterns[getIndex(magnitude, StandardPlural::OTHER)];
118	}
119	if (patternString == USE_FALLBACK) { // == is intended
120	// Return null if USE_FALLBACK is present
121	patternString = nullptr;
122	}
123	return patternString;
124	}
125
126	void CompactData::getUniquePatterns(UVector &output, UErrorCode &status) const {
127	U_ASSERT(output.isEmpty());
128	// NOTE: In C++, this is done more manually with a UVector.
129	// In Java, we can take advantage of JDK HashSet.
130	for (auto pattern : patterns) {
131	if (pattern == nullptr \|\| pattern == USE_FALLBACK) {
132	continue;
133	}
134
135	// Insert pattern into the UVector if the UVector does not already contain the pattern.
136	// Search the UVector from the end since identical patterns are likely to be adjacent.
137	for (int32_t i = output.size() - 1; i >= 0; i--) {
138	if (u_strcmp(pattern, static_cast<const UChar *>(output[i])) == 0) {
139	goto continue_outer;
140	}
141	}
142
143	// The string was not found; add it to the UVector.
144	// ANDY: This requires a const_cast. Why?
145	output.addElement(const_cast<UChar *>(pattern), status);
146
147	continue_outer:
148	continue;
149	}
150	}
151
152	void CompactData::CompactDataSink::put(const char key, ResourceValue &value, UBool /noFallback*/,
153	UErrorCode &status) {
154	// traverse into the table of powers of ten
155	ResourceTable powersOfTenTable = value.getTable(status);
156	if (U_FAILURE(status)) { return; }
157	for (int i3 = 0; powersOfTenTable.getKeyAndValue(i3, key, value); ++i3) {
158
159	// Assumes that the keys are always of the form "10000" where the magnitude is the
160	// length of the key minus one. We expect magnitudes to be less than MAX_DIGITS.
161	auto magnitude = static_cast<int8_t> (strlen(key) - 1);
162	int8_t multiplier = data.multipliers[magnitude];
163	U_ASSERT(magnitude < COMPACT_MAX_DIGITS);
164
165	// Iterate over the plural variants ("one", "other", etc)
166	ResourceTable pluralVariantsTable = value.getTable(status);
167	if (U_FAILURE(status)) { return; }
168	for (int i4 = 0; pluralVariantsTable.getKeyAndValue(i4, key, value); ++i4) {
169
170	// Skip this magnitude/plural if we already have it from a child locale.
171	// Note: This also skips USE_FALLBACK entries.
172	StandardPlural::Form plural = StandardPlural::fromString(key, status);
173	if (U_FAILURE(status)) { return; }
174	if (data.patterns[getIndex(magnitude, plural)] != nullptr) {
175	continue;
176	}
177
178	// The value "0" means that we need to use the default pattern and not fall back
179	// to parent locales. Example locale where this is relevant: 'it'.
180	int32_t patternLength;
181	const UChar *patternString = value.getString(patternLength, status);
182	if (U_FAILURE(status)) { return; }
183	if (u_strcmp(patternString, u"0") == 0) {
184	patternString = USE_FALLBACK;
185	patternLength = 0;
186	}
187
188	// Save the pattern string. We will parse it lazily.
189	data.patterns[getIndex(magnitude, plural)] = patternString;
190
191	// If necessary, compute the multiplier: the difference between the magnitude
192	// and the number of zeros in the pattern.
193	if (multiplier == 0) {
194	int32_t numZeros = countZeros(patternString, patternLength);
195	if (numZeros > 0) { // numZeros==0 in certain cases, like Somali "Kun"
196	multiplier = static_cast<int8_t> (numZeros - magnitude - 1);
197	}
198	}
199	}
200
201	// Save the multiplier.
202	if (data.multipliers[magnitude] == 0) {
203	data.multipliers[magnitude] = multiplier;
204	if (magnitude > data.largestMagnitude) {
205	data.largestMagnitude = magnitude;
206	}
207	data.isEmpty = false;
208	} else {
209	U_ASSERT(data.multipliers[magnitude] == multiplier);
210	}
211	}
212	}
213
214	///////////////////////////////////////////////////////////
215	/// END OF CompactData.java; BEGIN CompactNotation.java ///
216	///////////////////////////////////////////////////////////
217
218	CompactHandler::CompactHandler(CompactStyle compactStyle, const Locale &locale, const char *nsName,
219	CompactType compactType, const PluralRules *rules,
220	MutablePatternModifier buildReference, const MicroPropsGenerator parent,
221	UErrorCode &status)
222	: rules(rules), parent(parent) {
223	data.populate(locale, nsName, compactStyle, compactType, status);
224	if (buildReference != nullptr) {
225	// Safe code path
226	precomputeAllModifiers(*buildReference, status);
227	safe = TRUE;
228	} else {
229	// Unsafe code path
230	safe = FALSE;
231	}
232	}
233
234	CompactHandler::~CompactHandler() {
235	for (int32_t i = 0; i < precomputedModsLength; i++) {
236	delete precomputedMods[i].mod;
237	}
238	}
239
240	void CompactHandler::precomputeAllModifiers(MutablePatternModifier &buildReference, UErrorCode &status) {
241	if (U_FAILURE(status)) { return; }
242
243	// Initial capacity of 12 for 0K, 00K, 000K, ...M, ...B, and ...T
244	UVector allPatterns(12, status);
245	if (U_FAILURE(status)) { return; }
246	data.getUniquePatterns(allPatterns, status);
247	if (U_FAILURE(status)) { return; }
248
249	// C++ only: ensure that precomputedMods has room.
250	precomputedModsLength = allPatterns.size();
251	if (precomputedMods.getCapacity() < precomputedModsLength) {
252	precomputedMods.resize(allPatterns.size(), status);
253	if (U_FAILURE(status)) { return; }
254	}
255
256	for (int32_t i = 0; i < precomputedModsLength; i++) {
257	auto patternString = static_cast<const UChar *>(allPatterns[i]);
258	UnicodeString hello(patternString);
259	CompactModInfo &info = precomputedMods[i];
260	ParsedPatternInfo patternInfo;
261	PatternParser::parseToPatternInfo(UnicodeString(patternString), patternInfo, status);
262	if (U_FAILURE(status)) { return; }
3d1f044b	263	buildReference.setPatternInfo(&patternInfo, UNUM_COMPACT_FIELD);
0f5d89e8 A	264	info.mod = buildReference.createImmutable(status);
	265	if (U_FAILURE(status)) { return; }
	266	info.patternString = patternString;
	267	}
	268	}
	269
	270	void CompactHandler::processQuantity(DecimalQuantity &quantity, MicroProps &micros,
	271	UErrorCode &status) const {
	272	parent->processQuantity(quantity, micros, status);
	273	if (U_FAILURE(status)) { return; }
	274
	275	// Treat zero as if it had magnitude 0
3d1f044b	276	int32_t magnitude;
0f5d89e8 A	277	if (quantity.isZero()) {
	278	magnitude = 0;
	279	micros.rounder.apply(quantity, status);
	280	} else {
	281	// TODO: Revisit chooseMultiplierAndApply
3d1f044b	282	int32_t multiplier = micros.rounder.chooseMultiplierAndApply(quantity, data, status);
0f5d89e8 A	283	magnitude = quantity.isZero() ? 0 : quantity.getMagnitude();
	284	magnitude -= multiplier;
	285	}
	286
	287	StandardPlural::Form plural = utils::getStandardPlural(rules, quantity);
	288	const UChar *patternString = data.getPattern(magnitude, plural);
	289	if (patternString == nullptr) {
	290	// Use the default (non-compact) modifier.
	291	// No need to take any action.
	292	} else if (safe) {
	293	// Safe code path.
	294	// Java uses a hash set here for O(1) lookup. C++ uses a linear search.
	295	// TODO: Benchmark this and maybe change to a binary search or hash table.
	296	int32_t i = 0;
	297	for (; i < precomputedModsLength; i++) {
	298	const CompactModInfo &info = precomputedMods[i];
	299	if (u_strcmp(patternString, info.patternString) == 0) {
3d1f044b	300	info.mod->applyToMicros(micros, quantity, status);
0f5d89e8 A	301	break;
	302	}
	303	}
	304	// It should be guaranteed that we found the entry.
	305	U_ASSERT(i < precomputedModsLength);
	306	} else {
	307	// Unsafe code path.
	308	// Overwrite the PatternInfo in the existing modMiddle.
	309	// C++ Note: Use unsafePatternInfo for proper lifecycle.
	310	ParsedPatternInfo &patternInfo = const_cast<CompactHandler *>(this)->unsafePatternInfo;
	311	PatternParser::parseToPatternInfo(UnicodeString(patternString), patternInfo, status);
	312	static_cast<MutablePatternModifier>(const_cast<Modifier>(micros.modMiddle))
3d1f044b	313	->setPatternInfo(&patternInfo, UNUM_COMPACT_FIELD);
0f5d89e8 A	314	}
	315
	316	// We already performed rounding. Do not perform it again.
	317	micros.rounder = RoundingImpl::passThrough();
	318	}
	319
	320	#endif /* #if !UCONFIG_NO_FORMATTING */