[apple/icu.git] / icuSources / i18n / number_longnames.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/simpleformatter.h"
#include "unicode/ures.h"
#include "ureslocs.h"
#include "charstr.h"
#include "uresimp.h"
#include "number_longnames.h"
#include "number_microprops.h"
#include <algorithm>
#include "cstring.h"

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

namespace {

constexpr int32_t DNAM_INDEX = StandardPlural::Form::COUNT;
constexpr int32_t PER_INDEX = StandardPlural::Form::COUNT + 1;
constexpr int32_t ARRAY_LENGTH = StandardPlural::Form::COUNT + 2;

static int32_t getIndex(const char* pluralKeyword, UErrorCode& status) {
    // pluralKeyword can also be "dnam" or "per"
    if (uprv_strcmp(pluralKeyword, "dnam") == 0) {
        return DNAM_INDEX;
    } else if (uprv_strcmp(pluralKeyword, "per") == 0) {
        return PER_INDEX;
    } else {
        StandardPlural::Form plural = StandardPlural::fromString(pluralKeyword, status);
        return plural;
    }
}

static UnicodeString getWithPlural(
        const UnicodeString* strings,
        int32_t plural,
        UErrorCode& status) {
    UnicodeString result = strings[plural];
    if (result.isBogus()) {
        result = strings[StandardPlural::Form::OTHER];
    }
    if (result.isBogus()) {
        // There should always be data in the "other" plural variant.
        status = U_INTERNAL_PROGRAM_ERROR;
    }
    return result;
}


//////////////////////////
/// BEGIN DATA LOADING ///
//////////////////////////

class PluralTableSink : public ResourceSink {
  public:
    explicit PluralTableSink(UnicodeString *outArray) : outArray(outArray) {
        // Initialize the array to bogus strings.
        for (int32_t i = 0; i < ARRAY_LENGTH; i++) {
            outArray[i].setToBogus();
        }
    }

    void put(const char *key, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) U_OVERRIDE {
        ResourceTable pluralsTable = value.getTable(status);
        if (U_FAILURE(status)) { return; }
        for (int32_t i = 0; pluralsTable.getKeyAndValue(i, key, value); ++i) {
            int32_t index = getIndex(key, status);
            if (U_FAILURE(status)) { return; }
            if (!outArray[index].isBogus()) {
                continue;
            }
            outArray[index] = value.getUnicodeString(status);
            if (U_FAILURE(status)) { return; }
        }
    }

  private:
    UnicodeString *outArray;
};

// NOTE: outArray MUST have room for all StandardPlural values.  No bounds checking is performed.

void getMeasureData(const Locale &locale, const MeasureUnit &unit, const UNumberUnitWidth &width,
                    UnicodeString *outArray, UErrorCode &status) {
    PluralTableSink sink(outArray);
    LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, locale.getName(), &status));
    if (U_FAILURE(status)) { return; }
    CharString key;
    key.append("units", status);
    if (width == UNUM_UNIT_WIDTH_NARROW) {
        key.append("Narrow", status);
    } else if (width == UNUM_UNIT_WIDTH_SHORT) {
        key.append("Short", status);
    }
    key.append("/", status);
    key.append(unit.getType(), status);
    key.append("/", status);
    key.append(unit.getSubtype(), status);
    ures_getAllItemsWithFallback(unitsBundle.getAlias(), key.data(), sink, status);
}

void getCurrencyLongNameData(const Locale &locale, const CurrencyUnit &currency, UnicodeString *outArray,
                             UErrorCode &status) {
    // In ICU4J, this method gets a CurrencyData from CurrencyData.provider.
    // TODO(ICU4J): Implement this without going through CurrencyData, like in ICU4C?
    PluralTableSink sink(outArray);
    LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_CURR, locale.getName(), &status));
    if (U_FAILURE(status)) { return; }
    ures_getAllItemsWithFallback(unitsBundle.getAlias(), "CurrencyUnitPatterns", sink, status);
    if (U_FAILURE(status)) { return; }
    for (int32_t i = 0; i < StandardPlural::Form::COUNT; i++) {
        UnicodeString &pattern = outArray[i];
        if (pattern.isBogus()) {
            continue;
        }
        UBool isChoiceFormat = FALSE;
        int32_t longNameLen = 0;
        const char16_t *longName = ucurr_getPluralName(
                currency.getISOCurrency(),
                locale.getName(),
                &isChoiceFormat,
                StandardPlural::getKeyword(static_cast<StandardPlural::Form>(i)),
                &longNameLen,
                &status);
        // Example pattern from data: "{0} {1}"
        // Example output after find-and-replace: "{0} US dollars"
        pattern.findAndReplace(UnicodeString(u"{1}"), UnicodeString(longName, longNameLen));
    }
}

UnicodeString getPerUnitFormat(const Locale& locale, const UNumberUnitWidth &width, UErrorCode& status) {
    LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, locale.getName(), &status));
    if (U_FAILURE(status)) { return {}; }
    CharString key;
    key.append("units", status);
    if (width == UNUM_UNIT_WIDTH_NARROW) {
        key.append("Narrow", status);
    } else if (width == UNUM_UNIT_WIDTH_SHORT) {
        key.append("Short", status);
    }
    key.append("/compound/per", status);
    int32_t len = 0;
    const UChar* ptr = ures_getStringByKeyWithFallback(unitsBundle.getAlias(), key.data(), &len, &status);
    return UnicodeString(ptr, len);
}

////////////////////////
/// END DATA LOADING ///
////////////////////////

} // namespace

LongNameHandler
LongNameHandler::forMeasureUnit(const Locale &loc, const MeasureUnit &unitRef, const MeasureUnit &perUnit,
                                const UNumberUnitWidth &width, const PluralRules *rules,
                                const MicroPropsGenerator *parent, UErrorCode &status) {
    MeasureUnit unit = unitRef;
    if (uprv_strcmp(perUnit.getType(), "none") != 0) {
        // Compound unit: first try to simplify (e.g., meters per second is its own unit).
        bool isResolved = false;
        MeasureUnit resolved = MeasureUnit::resolveUnitPerUnit(unit, perUnit, &isResolved);
        if (isResolved) {
            unit = resolved;
        } else {
            // No simplified form is available.
            return forCompoundUnit(loc, unit, perUnit, width, rules, parent, status);
        }
    }

    LongNameHandler result(rules, parent);
    UnicodeString simpleFormats[ARRAY_LENGTH];
    getMeasureData(loc, unit, width, simpleFormats, status);
    if (U_FAILURE(status)) { return result; }
    // TODO: What field to use for units?
    simpleFormatsToModifiers(simpleFormats, UNUM_FIELD_COUNT, result.fModifiers, status);
    return result;
}

LongNameHandler
LongNameHandler::forCompoundUnit(const Locale &loc, const MeasureUnit &unit, const MeasureUnit &perUnit,
                                 const UNumberUnitWidth &width, const PluralRules *rules,
                                 const MicroPropsGenerator *parent, UErrorCode &status) {
    LongNameHandler result(rules, parent);
    UnicodeString primaryData[ARRAY_LENGTH];
    getMeasureData(loc, unit, width, primaryData, status);
    if (U_FAILURE(status)) { return result; }
    UnicodeString secondaryData[ARRAY_LENGTH];
    getMeasureData(loc, perUnit, width, secondaryData, status);
    if (U_FAILURE(status)) { return result; }

    UnicodeString perUnitFormat;
    if (!secondaryData[PER_INDEX].isBogus()) {
        perUnitFormat = secondaryData[PER_INDEX];
    } else {
        UnicodeString rawPerUnitFormat = getPerUnitFormat(loc, width, status);
        if (U_FAILURE(status)) { return result; }
        // rawPerUnitFormat is something like "{0}/{1}"; we need to substitute in the secondary unit.
        SimpleFormatter compiled(rawPerUnitFormat, 2, 2, status);
        if (U_FAILURE(status)) { return result; }
        UnicodeString secondaryFormat = getWithPlural(secondaryData, StandardPlural::Form::ONE, status);
        if (U_FAILURE(status)) { return result; }
        SimpleFormatter secondaryCompiled(secondaryFormat, 1, 1, status);
        if (U_FAILURE(status)) { return result; }
        UnicodeString secondaryString = secondaryCompiled.getTextWithNoArguments().trim();
        // TODO: Why does UnicodeString need to be explicit in the following line?
        compiled.format(UnicodeString(u"{0}"), secondaryString, perUnitFormat, status);
        if (U_FAILURE(status)) { return result; }
    }
    // TODO: What field to use for units?
    multiSimpleFormatsToModifiers(primaryData, perUnitFormat, UNUM_FIELD_COUNT, result.fModifiers, status);
    return result;
}

LongNameHandler LongNameHandler::forCurrencyLongNames(const Locale &loc, const CurrencyUnit &currency,
                                                      const PluralRules *rules,
                                                      const MicroPropsGenerator *parent,
                                                      UErrorCode &status) {
    LongNameHandler result(rules, parent);
    UnicodeString simpleFormats[ARRAY_LENGTH];
    getCurrencyLongNameData(loc, currency, simpleFormats, status);
    if (U_FAILURE(status)) { return result; }
    simpleFormatsToModifiers(simpleFormats, UNUM_CURRENCY_FIELD, result.fModifiers, status);
    return result;
}

void LongNameHandler::simpleFormatsToModifiers(const UnicodeString *simpleFormats, Field field,
                                               SimpleModifier *output, UErrorCode &status) {
    for (int32_t i = 0; i < StandardPlural::Form::COUNT; i++) {
        UnicodeString simpleFormat = getWithPlural(simpleFormats, i, status);
        if (U_FAILURE(status)) { return; }
        SimpleFormatter compiledFormatter(simpleFormat, 0, 1, status);
        if (U_FAILURE(status)) { return; }
        output[i] = SimpleModifier(compiledFormatter, field, false);
    }
}

void LongNameHandler::multiSimpleFormatsToModifiers(const UnicodeString *leadFormats, UnicodeString trailFormat,
                                                    Field field, SimpleModifier *output, UErrorCode &status) {
    SimpleFormatter trailCompiled(trailFormat, 1, 1, status);
    if (U_FAILURE(status)) { return; }
    for (int32_t i = 0; i < StandardPlural::Form::COUNT; i++) {
        UnicodeString leadFormat = getWithPlural(leadFormats, i, status);
        if (U_FAILURE(status)) { return; }
        UnicodeString compoundFormat;
        trailCompiled.format(leadFormat, compoundFormat, status);
        if (U_FAILURE(status)) { return; }
        SimpleFormatter compoundCompiled(compoundFormat, 0, 1, status);
        if (U_FAILURE(status)) { return; }
        output[i] = SimpleModifier(compoundCompiled, field, false);
    }
}

void LongNameHandler::processQuantity(DecimalQuantity &quantity, MicroProps &micros,
                                      UErrorCode &status) const {
    parent->processQuantity(quantity, micros, status);
    // TODO: Avoid the copy here?
    DecimalQuantity copy(quantity);
    micros.rounder.apply(copy, status);
    micros.modOuter = &fModifiers[utils::getStandardPlural(rules, copy)];
}

#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/simpleformatter.h"
	9	#include "unicode/ures.h"
	10	#include "ureslocs.h"
	11	#include "charstr.h"
	12	#include "uresimp.h"
	13	#include "number_longnames.h"
	14	#include "number_microprops.h"
	15	#include <algorithm>
	16	#include "cstring.h"
	17
	18	using namespace icu;
	19	using namespace icu::number;
	20	using namespace icu::number::impl;
	21
	22	namespace {
	23
	24	constexpr int32_t DNAM_INDEX = StandardPlural::Form::COUNT;
	25	constexpr int32_t PER_INDEX = StandardPlural::Form::COUNT + 1;
	26	constexpr int32_t ARRAY_LENGTH = StandardPlural::Form::COUNT + 2;
	27
	28	static int32_t getIndex(const char* pluralKeyword, UErrorCode& status) {
	29	// pluralKeyword can also be "dnam" or "per"
	30	if (uprv_strcmp(pluralKeyword, "dnam") == 0) {
	31	return DNAM_INDEX;
	32	} else if (uprv_strcmp(pluralKeyword, "per") == 0) {
	33	return PER_INDEX;
	34	} else {
	35	StandardPlural::Form plural = StandardPlural::fromString(pluralKeyword, status);
	36	return plural;
	37	}
	38	}
	39
	40	static UnicodeString getWithPlural(
	41	const UnicodeString* strings,
	42	int32_t plural,
	43	UErrorCode& status) {
	44	UnicodeString result = strings[plural];
	45	if (result.isBogus()) {
	46	result = strings[StandardPlural::Form::OTHER];
	47	}
	48	if (result.isBogus()) {
	49	// There should always be data in the "other" plural variant.
	50	status = U_INTERNAL_PROGRAM_ERROR;
	51	}
	52	return result;
	53	}
	54
	55
	56	//////////////////////////
	57	/// BEGIN DATA LOADING ///
	58	//////////////////////////
	59
	60	class PluralTableSink : public ResourceSink {
	61	public:
	62	explicit PluralTableSink(UnicodeString *outArray) : outArray(outArray) {
	63	// Initialize the array to bogus strings.
	64	for (int32_t i = 0; i < ARRAY_LENGTH; i++) {
65	outArray[i].setToBogus();
66	}
67	}
68
69	void put(const char key, ResourceValue &value, UBool /noFallback*/, UErrorCode &status) U_OVERRIDE {
70	ResourceTable pluralsTable = value.getTable(status);
71	if (U_FAILURE(status)) { return; }
72	for (int32_t i = 0; pluralsTable.getKeyAndValue(i, key, value); ++i) {
73	int32_t index = getIndex(key, status);
74	if (U_FAILURE(status)) { return; }
75	if (!outArray[index].isBogus()) {
76	continue;
77	}
78	outArray[index] = value.getUnicodeString(status);
79	if (U_FAILURE(status)) { return; }
80	}
81	}
82
83	private:
84	UnicodeString *outArray;
85	};
86
87	// NOTE: outArray MUST have room for all StandardPlural values. No bounds checking is performed.
88
89	void getMeasureData(const Locale &locale, const MeasureUnit &unit, const UNumberUnitWidth &width,
90	UnicodeString *outArray, UErrorCode &status) {
91	PluralTableSink sink(outArray);
92	LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, locale.getName(), &status));
93	if (U_FAILURE(status)) { return; }
94	CharString key;
95	key.append("units", status);
96	if (width == UNUM_UNIT_WIDTH_NARROW) {
97	key.append("Narrow", status);
98	} else if (width == UNUM_UNIT_WIDTH_SHORT) {
99	key.append("Short", status);
100	}
101	key.append("/", status);
102	key.append(unit.getType(), status);
103	key.append("/", status);
104	key.append(unit.getSubtype(), status);
105	ures_getAllItemsWithFallback(unitsBundle.getAlias(), key.data(), sink, status);
106	}
107
108	void getCurrencyLongNameData(const Locale &locale, const CurrencyUnit &currency, UnicodeString *outArray,
109	UErrorCode &status) {
110	// In ICU4J, this method gets a CurrencyData from CurrencyData.provider.
111	// TODO(ICU4J): Implement this without going through CurrencyData, like in ICU4C?
112	PluralTableSink sink(outArray);
113	LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_CURR, locale.getName(), &status));
114	if (U_FAILURE(status)) { return; }
115	ures_getAllItemsWithFallback(unitsBundle.getAlias(), "CurrencyUnitPatterns", sink, status);
116	if (U_FAILURE(status)) { return; }
117	for (int32_t i = 0; i < StandardPlural::Form::COUNT; i++) {
118	UnicodeString &pattern = outArray[i];
119	if (pattern.isBogus()) {
120	continue;
121	}
122	UBool isChoiceFormat = FALSE;
123	int32_t longNameLen = 0;
124	const char16_t *longName = ucurr_getPluralName(
125	currency.getISOCurrency(),
126	locale.getName(),
127	&isChoiceFormat,
128	StandardPlural::getKeyword(static_cast<StandardPlural::Form>(i)),
129	&longNameLen,
130	&status);
131	// Example pattern from data: "{0} {1}"
132	// Example output after find-and-replace: "{0} US dollars"
133	pattern.findAndReplace(UnicodeString(u"{1}"), UnicodeString(longName, longNameLen));
134	}
135	}
136
137	UnicodeString getPerUnitFormat(const Locale& locale, const UNumberUnitWidth &width, UErrorCode& status) {
138	LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, locale.getName(), &status));
139	if (U_FAILURE(status)) { return {}; }
140	CharString key;
141	key.append("units", status);
142	if (width == UNUM_UNIT_WIDTH_NARROW) {
143	key.append("Narrow", status);
144	} else if (width == UNUM_UNIT_WIDTH_SHORT) {
145	key.append("Short", status);
146	}
147	key.append("/compound/per", status);
148	int32_t len = 0;
149	const UChar* ptr = ures_getStringByKeyWithFallback(unitsBundle.getAlias(), key.data(), &len, &status);
150	return UnicodeString(ptr, len);
151	}
152
153	////////////////////////
154	/// END DATA LOADING ///
155	////////////////////////
156
157	} // namespace
158
159	LongNameHandler
160	LongNameHandler::forMeasureUnit(const Locale &loc, const MeasureUnit &unitRef, const MeasureUnit &perUnit,
161	const UNumberUnitWidth &width, const PluralRules *rules,
162	const MicroPropsGenerator *parent, UErrorCode &status) {
163	MeasureUnit unit = unitRef;
164	if (uprv_strcmp(perUnit.getType(), "none") != 0) {
165	// Compound unit: first try to simplify (e.g., meters per second is its own unit).
166	bool isResolved = false;
167	MeasureUnit resolved = MeasureUnit::resolveUnitPerUnit(unit, perUnit, &isResolved);
168	if (isResolved) {
169	unit = resolved;
170	} else {
171	// No simplified form is available.
172	return forCompoundUnit(loc, unit, perUnit, width, rules, parent, status);
173	}
174	}
175
176	LongNameHandler result(rules, parent);
177	UnicodeString simpleFormats[ARRAY_LENGTH];
178	getMeasureData(loc, unit, width, simpleFormats, status);
179	if (U_FAILURE(status)) { return result; }
180	// TODO: What field to use for units?
181	simpleFormatsToModifiers(simpleFormats, UNUM_FIELD_COUNT, result.fModifiers, status);
182	return result;
183	}
184
185	LongNameHandler
186	LongNameHandler::forCompoundUnit(const Locale &loc, const MeasureUnit &unit, const MeasureUnit &perUnit,
187	const UNumberUnitWidth &width, const PluralRules *rules,
188	const MicroPropsGenerator *parent, UErrorCode &status) {
189	LongNameHandler result(rules, parent);
190	UnicodeString primaryData[ARRAY_LENGTH];
191	getMeasureData(loc, unit, width, primaryData, status);
192	if (U_FAILURE(status)) { return result; }
193	UnicodeString secondaryData[ARRAY_LENGTH];
194	getMeasureData(loc, perUnit, width, secondaryData, status);
195	if (U_FAILURE(status)) { return result; }
196
197	UnicodeString perUnitFormat;
198	if (!secondaryData[PER_INDEX].isBogus()) {
199	perUnitFormat = secondaryData[PER_INDEX];
200	} else {
201	UnicodeString rawPerUnitFormat = getPerUnitFormat(loc, width, status);
202	if (U_FAILURE(status)) { return result; }
203	// rawPerUnitFormat is something like "{0}/{1}"; we need to substitute in the secondary unit.
204	SimpleFormatter compiled(rawPerUnitFormat, 2, 2, status);
205	if (U_FAILURE(status)) { return result; }
206	UnicodeString secondaryFormat = getWithPlural(secondaryData, StandardPlural::Form::ONE, status);
207	if (U_FAILURE(status)) { return result; }
208	SimpleFormatter secondaryCompiled(secondaryFormat, 1, 1, status);
209	if (U_FAILURE(status)) { return result; }
210	UnicodeString secondaryString = secondaryCompiled.getTextWithNoArguments().trim();
211	// TODO: Why does UnicodeString need to be explicit in the following line?
212	compiled.format(UnicodeString(u"{0}"), secondaryString, perUnitFormat, status);
213	if (U_FAILURE(status)) { return result; }
214	}
215	// TODO: What field to use for units?
216	multiSimpleFormatsToModifiers(primaryData, perUnitFormat, UNUM_FIELD_COUNT, result.fModifiers, status);
217	return result;
218	}
219
220	LongNameHandler LongNameHandler::forCurrencyLongNames(const Locale &loc, const CurrencyUnit &currency,
221	const PluralRules *rules,
222	const MicroPropsGenerator *parent,
223	UErrorCode &status) {
224	LongNameHandler result(rules, parent);
225	UnicodeString simpleFormats[ARRAY_LENGTH];
226	getCurrencyLongNameData(loc, currency, simpleFormats, status);
227	if (U_FAILURE(status)) { return result; }
228	simpleFormatsToModifiers(simpleFormats, UNUM_CURRENCY_FIELD, result.fModifiers, status);
229	return result;
230	}
231
232	void LongNameHandler::simpleFormatsToModifiers(const UnicodeString *simpleFormats, Field field,
233	SimpleModifier *output, UErrorCode &status) {
234	for (int32_t i = 0; i < StandardPlural::Form::COUNT; i++) {
235	UnicodeString simpleFormat = getWithPlural(simpleFormats, i, status);
236	if (U_FAILURE(status)) { return; }
237	SimpleFormatter compiledFormatter(simpleFormat, 0, 1, status);
238	if (U_FAILURE(status)) { return; }
239	output[i] = SimpleModifier(compiledFormatter, field, false);
240	}
241	}
242
243	void LongNameHandler::multiSimpleFormatsToModifiers(const UnicodeString *leadFormats, UnicodeString trailFormat,
244	Field field, SimpleModifier *output, UErrorCode &status) {
245	SimpleFormatter trailCompiled(trailFormat, 1, 1, status);
246	if (U_FAILURE(status)) { return; }
247	for (int32_t i = 0; i < StandardPlural::Form::COUNT; i++) {
248	UnicodeString leadFormat = getWithPlural(leadFormats, i, status);
249	if (U_FAILURE(status)) { return; }
250	UnicodeString compoundFormat;
251	trailCompiled.format(leadFormat, compoundFormat, status);
252	if (U_FAILURE(status)) { return; }
253	SimpleFormatter compoundCompiled(compoundFormat, 0, 1, status);
254	if (U_FAILURE(status)) { return; }
255	output[i] = SimpleModifier(compoundCompiled, field, false);
256	}
257	}
258
259	void LongNameHandler::processQuantity(DecimalQuantity &quantity, MicroProps &micros,
260	UErrorCode &status) const {
261	parent->processQuantity(quantity, micros, status);
262	// TODO: Avoid the copy here?
263	DecimalQuantity copy(quantity);
264	micros.rounder.apply(copy, status);
265	micros.modOuter = &fModifiers[utils::getStandardPlural(rules, copy)];
266	}
267
268	#endif /* #if !UCONFIG_NO_FORMATTING */