com.ibm.icu.impl.number.LongNameHandler Maven / Gradle / Ivy
Show all versions of icu4j Show documentation
// © 2017 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
package com.ibm.icu.impl.number;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.Set;
import com.ibm.icu.impl.CurrencyData;
import com.ibm.icu.impl.ICUData;
import com.ibm.icu.impl.ICUResourceBundle;
import com.ibm.icu.impl.PatternProps;
import com.ibm.icu.impl.SimpleFormatterImpl;
import com.ibm.icu.impl.StandardPlural;
import com.ibm.icu.impl.UResource;
import com.ibm.icu.impl.number.Modifier.Signum;
import com.ibm.icu.impl.units.MeasureUnitImpl;
import com.ibm.icu.impl.units.SingleUnitImpl;
import com.ibm.icu.lang.UCharacter;
import com.ibm.icu.number.NumberFormatter.UnitWidth;
import com.ibm.icu.text.NumberFormat;
import com.ibm.icu.text.PluralRules;
import com.ibm.icu.util.Currency;
import com.ibm.icu.util.ICUException;
import com.ibm.icu.util.MeasureUnit;
import com.ibm.icu.util.MeasureUnit.Complexity;
import com.ibm.icu.util.MeasureUnit.MeasurePrefix;
import com.ibm.icu.util.ULocale;
import com.ibm.icu.util.UResourceBundle;
/**
* Takes care of formatting currency and measurement unit names, as well as populating the gender of measure units.
*/
public class LongNameHandler
implements MicroPropsGenerator, ModifierStore, LongNameMultiplexer.ParentlessMicroPropsGenerator {
private static int i = 0;
private static final int DNAM_INDEX = StandardPlural.COUNT + i++;
private static final int PER_INDEX = StandardPlural.COUNT + i++;
private static final int GENDER_INDEX = StandardPlural.COUNT + i++;
static final int ARRAY_LENGTH = StandardPlural.COUNT + i++;
// Returns the array index that corresponds to the given pluralKeyword.
private static int getIndex(String pluralKeyword) {
// pluralKeyword can also be "dnam", "per" or "gender"
if (pluralKeyword.equals("dnam")) {
return DNAM_INDEX;
} else if (pluralKeyword.equals("per")) {
return PER_INDEX;
} else if (pluralKeyword.equals("gender")) {
return GENDER_INDEX;
} else {
return StandardPlural.fromString(pluralKeyword).ordinal();
}
}
static String getWithPlural(String[] strings, StandardPlural plural) {
String result = strings[plural.ordinal()];
if (result == null) {
result = strings[StandardPlural.OTHER.ordinal()];
}
if (result == null) {
// There should always be data in the "other" plural variant.
throw new ICUException("Could not find data in 'other' plural variant");
}
return result;
}
private enum PlaceholderPosition { NONE, BEGINNING, MIDDLE, END }
private static class ExtractCorePatternResult {
String coreUnit;
PlaceholderPosition placeholderPosition;
char joinerChar;
}
/**
* Returns three outputs extracted from pattern.
*
* @param coreUnit is extracted as per Extract(...) in the spec:
* https://unicode.org/reports/tr35/tr35-general.html#compound-units
* @param PlaceholderPosition indicates where in the string the placeholder
* was found.
* @param joinerChar Iff the placeholder was at the beginning or end,
* joinerChar contains the space character (if any) that separated the
* placeholder from the rest of the pattern. Otherwise, joinerChar is set
* to NUL. Only one space character is considered.
*/
private static ExtractCorePatternResult extractCorePattern(String pattern) {
ExtractCorePatternResult result = new ExtractCorePatternResult();
result.joinerChar = 0;
int len = pattern.length();
if (pattern.startsWith("{0}")) {
result.placeholderPosition = PlaceholderPosition.BEGINNING;
if (len > 3 && Character.isSpaceChar(pattern.charAt(3))) {
result.joinerChar = pattern.charAt(3);
result.coreUnit = pattern.substring(4);
} else {
result.coreUnit = pattern.substring(3);
}
} else if (pattern.endsWith("{0}")) {
result.placeholderPosition = PlaceholderPosition.END;
if (Character.isSpaceChar(pattern.charAt(len - 4))) {
result.coreUnit = pattern.substring(0, len - 4);
result.joinerChar = pattern.charAt(len - 4);
} else {
result.coreUnit = pattern.substring(0, len - 3);
}
} else if (pattern.indexOf("{0}", 1) == -1) {
result.placeholderPosition = PlaceholderPosition.NONE;
result.coreUnit = pattern;
} else {
result.placeholderPosition = PlaceholderPosition.MIDDLE;
result.coreUnit = pattern;
}
return result;
}
//////////////////////////
/// BEGIN DATA LOADING ///
//////////////////////////
// Gets the gender of a built-in unit: unit must be a built-in. Returns an empty
// string both in case of unknown gender and in case of unknown unit.
private static String getGenderForBuiltin(ULocale locale, MeasureUnit builtinUnit) {
ICUResourceBundle unitsBundle = (ICUResourceBundle) UResourceBundle.getBundleInstance(ICUData.ICU_UNIT_BASE_NAME, locale);
StringBuilder key = new StringBuilder();
key.append("units/");
key.append(builtinUnit.getType());
key.append("/");
// Map duration-year-person, duration-week-person, etc. to duration-year, duration-week, ...
// TODO(ICU-20400): Get duration-*-person data properly with aliases.
if (builtinUnit.getSubtype() != null && builtinUnit.getSubtype().endsWith("-person")) {
key.append(builtinUnit.getSubtype(), 0, builtinUnit.getSubtype().length() - 7);
} else {
key.append(builtinUnit.getSubtype());
}
key.append("/gender");
try {
return unitsBundle.getWithFallback(key.toString()).getString();
} catch (MissingResourceException e) {
// TODO(icu-units#28): "$unitRes/gender" does not exist. Do we want to
// check whether the parent "$unitRes" exists? Then we could return
// U_MISSING_RESOURCE_ERROR for incorrect usage (e.g. builtinUnit not
// being a builtin).
return "";
}
}
// Loads data from a resource tree with paths matching
// $key/$pluralForm/$gender/$case, with lateral inheritance for missing cases
// and genders.
//
// An InflectedPluralSink is configured to load data for a specific gender and
// case. It loads all plural forms, because selection between plural forms is
// dependent upon the value being formatted.
//
// See data/unit/de.txt and data/unit/fr.txt for examples - take a look at
// units/compound/power2: German has case, French has differences for
// gender, but no case.
//
// TODO(icu-units#138): Conceptually similar to PluralTableSink, however the
// tree structures are different. After homogenizing the structures, we may be
// able to unify the two classes.
//
// TODO: Spec violation: expects presence of "count" - does not fallback to an
// absent "count"! If this fallback were added, getCompoundValue could be
// superseded?
private static final class InflectedPluralSink extends UResource.Sink {
// NOTE: outArray MUST have a length of at least ARRAY_LENGTH. No bounds
// checking is performed.
public InflectedPluralSink(String gender, String caseVariant, String[] outArray) {
this.gender = gender;
this.caseVariant = caseVariant;
this.outArray = outArray;
for (int i = 0; i < ARRAY_LENGTH; i++) {
outArray[i] = null;
}
}
// See ResourceSink::put().
@Override
public void put(UResource.Key key, UResource.Value value, boolean noFallback) {
UResource.Table pluralsTable = value.getTable();
for (int i = 0; pluralsTable.getKeyAndValue(i, key, value); ++i) {
String keyString = key.toString();
int pluralIndex = getIndex(keyString);
if (outArray[pluralIndex] != null) {
// We already have a pattern
continue;
}
UResource.Table genderTable = value.getTable();
if (loadForPluralForm(genderTable, value)) {
outArray[pluralIndex] = value.getString();
}
}
}
// Tries to load data for the configured gender from `genderTable`. The
// returned data will be for the configured gender if found, falling
// back to "neuter" and no-gender. If none of those are found, null is
// returned.
private boolean loadForPluralForm(UResource.Table genderTable, UResource.Value value) {
if (gender != null && !gender.isEmpty()) {
if (loadForGender(genderTable, gender, value)) {
return true;
}
if (gender != "neuter") {
if (loadForGender(genderTable, "neuter", value)) {
return true;
}
}
}
if (loadForGender(genderTable, "_", value)) {
return true;
}
return false;
}
// Tries to load data for the given gender from `genderTable`. Returns true
// if found, returning the data in `value`. The returned data will be for
// the configured case if found, falling back to "nominative" and no-case if
// not.
private boolean
loadForGender(UResource.Table genderTable, String genderVal, UResource.Value value) {
if (!genderTable.findValue(genderVal, value)) {
return false;
}
UResource.Table caseTable = value.getTable();
if (caseVariant != null && !caseVariant.isEmpty()) {
if (loadForCase(caseTable, caseVariant, value)) {
return true;
}
if (caseVariant != "nominative") {
if (loadForCase(caseTable, "nominative", value)) {
return true;
}
}
}
if (loadForCase(caseTable, "_", value)) {
return true;
}
return false;
}
// Tries to load data for the given case from `caseTable`. Returns null
// if not found.
private boolean loadForCase(UResource.Table caseTable, String caseValue, UResource.Value value) {
if (!caseTable.findValue(caseValue, value)) {
return false;
}
return true;
}
String gender;
String caseVariant;
String[] outArray;
}
// Fetches localised formatting patterns for the given subKey. See
// documentation for InflectedPluralSink for details.
//
// Data is loaded for the appropriate unit width, with missing data filled
// in from unitsShort.
static void getInflectedMeasureData(String subKey,
ULocale locale,
UnitWidth width,
String gender,
String caseVariant,
String[] outArray) {
InflectedPluralSink sink = new InflectedPluralSink(gender, caseVariant, outArray);
ICUResourceBundle unitsBundle =
(ICUResourceBundle)UResourceBundle.getBundleInstance(ICUData.ICU_UNIT_BASE_NAME, locale);
StringBuilder key = new StringBuilder();
key.append("units");
if (width == UnitWidth.NARROW) {
key.append("Narrow");
} else if (width == UnitWidth.SHORT) {
key.append("Short");
}
key.append("/");
key.append(subKey);
try {
unitsBundle.getAllItemsWithFallback(key.toString(), sink);
if (width == UnitWidth.SHORT) {
return;
}
} catch (MissingResourceException e) {
// Continue: fall back to short
}
unitsBundle.getAllItemsWithFallback(key.toString(), sink);
}
private static final class PluralTableSink extends UResource.Sink {
String[] outArray;
// NOTE: outArray MUST have at least ARRAY_LENGTH entries. No bounds
// checking is performed.
public PluralTableSink(String[] outArray) {
this.outArray = outArray;
}
@Override
public void put(UResource.Key key, UResource.Value value, boolean noFallback) {
UResource.Table pluralsTable = value.getTable();
for (int i = 0; pluralsTable.getKeyAndValue(i, key, value); ++i) {
String keyString = key.toString();
if (keyString.equals("case")) {
continue;
}
int index = getIndex(keyString);
if (outArray[index] != null) {
continue;
}
String formatString = value.getString();
outArray[index] = formatString;
}
}
}
private static final class AliasSink extends UResource.Sink {
String replacement;
@Override
public void put(UResource.Key key, UResource.Value value, boolean noFallback) {
UResource.Table aliasTable = value.getTable();
for (int i = 0; aliasTable.getKeyAndValue(i, key, value); ++i) {
String keyString = key.toString();
if (keyString.equals("replacement")) {
this.replacement = value.toString();
}
}
}
}
// NOTE: outArray MUST have at least ARRAY_LENGTH entries. No bounds checking is performed.
static void getMeasureData(
ULocale locale,
MeasureUnit unit,
UnitWidth width,
String unitDisplayCase,
String[] outArray) {
PluralTableSink sink = new PluralTableSink(outArray);
ICUResourceBundle resource;
resource = (ICUResourceBundle) UResourceBundle.getBundleInstance(ICUData.ICU_UNIT_BASE_NAME,
locale);
StringBuilder subKey = new StringBuilder();
subKey.append("/");
subKey.append(unit.getType());
subKey.append("/");
// If the unit is an alias, replace it is identifier with the replacement.
String unitSubType = unit.getSubtype();
ICUResourceBundle metadataResource = (ICUResourceBundle) UResourceBundle.getBundleInstance(ICUData.ICU_BASE_NAME, "metadata");
AliasSink aliasSink = new AliasSink();
metadataResource.getAllItemsWithFallbackNoFail("alias/unit/" + unitSubType, aliasSink);
if (aliasSink.replacement != null) {
unitSubType = aliasSink.replacement;
}
// Map duration-year-person, duration-week-person, etc. to duration-year, duration-week, ...
// TODO(ICU-20400): Get duration-*-person data properly with aliases.
if (unitSubType != null && unitSubType.endsWith("-person")) {
subKey.append(unitSubType, 0, unitSubType.length() - 7);
} else {
subKey.append(unitSubType);
}
if (width != UnitWidth.FULL_NAME) {
StringBuilder genderKey = new StringBuilder();
genderKey.append("units");
genderKey.append(subKey);
genderKey.append("/gender");
try {
outArray[GENDER_INDEX] = resource.getWithFallback(genderKey.toString()).getString();
} catch (MissingResourceException e) {
// continue
}
}
StringBuilder key = new StringBuilder();
key.append("units");
if (width == UnitWidth.NARROW) {
key.append("Narrow");
} else if (width == UnitWidth.SHORT) {
key.append("Short");
}
key.append(subKey);
// Grab desired case first, if available. Then grab nominative case to fill
// in the gaps.
//
// TODO(icu-units#138): check that fallback is spec-compliant
if (width == UnitWidth.FULL_NAME
&& unitDisplayCase != null
&& !unitDisplayCase.isEmpty()) {
StringBuilder caseKey = new StringBuilder();
caseKey.append(key);
caseKey.append("/case/");
caseKey.append(unitDisplayCase);
try {
// TODO(icu-units#138): our fallback logic is not spec-compliant:
// lateral fallback should happen before locale fallback. Switch to
// getInflectedMeasureData after homogenizing data format? Find a unit
// test case that demonstrates the incorrect fallback logic (via
// regional variant of an inflected language?)
resource.getAllItemsWithFallback(caseKey.toString(), sink);
// TODO(icu-units#138): our fallback logic is not spec-compliant: we
// check the given case, then go straight to the no-case data. The spec
// states we should first look for case="nominative". As part of #138,
// either get the spec changed, or add unit tests that warn us if
// case="nominative" data differs from no-case data?
} catch (MissingResourceException e) {
// continue.
}
}
try {
resource.getAllItemsWithFallback(key.toString(), sink);
} catch (MissingResourceException e) {
throw new IllegalArgumentException("No data for unit " + unit + ", width " + width, e);
}
}
private static void getCurrencyLongNameData(ULocale locale, Currency currency, String[] outArray) {
// In ICU4J, this method gets a CurrencyData from CurrencyData.provider.
// TODO(ICU4J): Implement this without going through CurrencyData, like in ICU4C?
Map data = CurrencyData.provider.getInstance(locale, true).getUnitPatterns();
// Entries in the data map are filled in with any CurrencyUnitPatterns data for locale,
// or if there is no CurrencyUnitPatterns data for locale since the patterns all inherited
// from the "other" pattern in root (which is true for many locales in CLDR 46), then only
// the "other" entry has a currency pattern. So now what we do is: For all valid plural keywords
// for the locale, if the corresponding outArray[] entry is bogus, fill it in from the "other"
// entry.
PluralRules prules = PluralRules.forLocale(locale);
Set keywords = prules.getKeywords();
String otherPattern = data.get("other");
if (keywords != null && otherPattern!= null) {
for (String keyword: keywords) {
if (!keyword.equals("other") && !data.containsKey(keyword)) {
data.put(keyword, otherPattern);
}
}
}
for (Map.Entry e : data.entrySet()) {
String pluralKeyword = e.getKey();
int index = getIndex(pluralKeyword);
String longName = currency.getName(locale, Currency.PLURAL_LONG_NAME, pluralKeyword, null);
String simpleFormat = e.getValue();
// Example pattern from data: "{0} {1}"
// Example output after find-and-replace: "{0} US dollars"
simpleFormat = simpleFormat.replace("{1}", longName);
// String compiled = SimpleFormatterImpl.compileToStringMinMaxArguments(simpleFormat, sb, 1,
// 1);
// SimpleModifier mod = new SimpleModifier(compiled, Field.CURRENCY, false);
outArray[index] = simpleFormat;
}
}
private static String getCompoundValue(String compoundKey, ULocale locale, UnitWidth width) {
ICUResourceBundle resource;
resource = (ICUResourceBundle) UResourceBundle.getBundleInstance(ICUData.ICU_UNIT_BASE_NAME,
locale);
StringBuilder key = new StringBuilder();
key.append("units");
if (width == UnitWidth.NARROW) {
key.append("Narrow");
} else if (width == UnitWidth.SHORT) {
key.append("Short");
}
key.append("/compound/");
key.append(compoundKey);
try {
return resource.getStringWithFallback(key.toString());
} catch (MissingResourceException e) {
if (width == UnitWidth.SHORT) {
return "";
}
}
try {
return resource.getStringWithFallback(key.toString());
} catch (MissingResourceException e) {
return "";
}
}
/**
* Loads and applies deriveComponent rules from CLDR's
* grammaticalFeatures.xml.
*
* Consider a deriveComponent rule that looks like this:
*
* <deriveComponent feature="case" structure="per" value0="compound" value1="nominative"/>
*
* Instantiating an instance as follows:
*
* DerivedComponents d(loc, "case", "per");
*
*
* Applying the rule in the XML element above, d.value0("foo")
* will be "foo", and d.value1("foo") will be "nominative".
*
* In case of any kind of failure, value0() and value1() will simply return
* "".
*/
private static class DerivedComponents {
/**
* Constructor.
*/
DerivedComponents(ULocale locale, String feature, String structure) {
try {
ICUResourceBundle derivationsBundle =
(ICUResourceBundle)UResourceBundle.getBundleInstance(ICUData.ICU_BASE_NAME,
"grammaticalFeatures");
derivationsBundle = (ICUResourceBundle)derivationsBundle.get("grammaticalData");
derivationsBundle = (ICUResourceBundle)derivationsBundle.get("derivations");
ICUResourceBundle stackBundle;
try {
// TODO: use standard normal locale resolution algorithms rather than just grabbing
// language:
stackBundle = (ICUResourceBundle)derivationsBundle.get(locale.getLanguage());
} catch (MissingResourceException e) {
stackBundle = (ICUResourceBundle)derivationsBundle.get("root");
}
stackBundle = (ICUResourceBundle)stackBundle.get("component");
stackBundle = (ICUResourceBundle)stackBundle.get(feature);
stackBundle = (ICUResourceBundle)stackBundle.get(structure);
String value = stackBundle.getString(0);
if (value.compareTo("compound") == 0) {
this.value0 = null;
} else {
this.value0 = value;
}
value = stackBundle.getString(1);
if (value.compareTo("compound") == 0) {
this.value1 = null;
} else {
this.value1 = value;
}
} catch (MissingResourceException e) {
// Fall back to uninflected.
}
}
String value0(String compoundValue) {
return (this.value0 != null) ? this.value0 : compoundValue;
}
String value1(String compoundValue) {
return (this.value1 != null) ? this.value1 : compoundValue;
}
private String value0 = "", value1 = "";
}
// TODO(icu-units#28): test somehow? Associate with an ICU ticket for adding
// testsuite support for testing with synthetic data?
/**
* Loads and returns the value in rules that look like these:
*
* singleUnits = mui.getSingleUnits();
int singleUnitIndex = 0;
if (mui.getComplexity() == MeasureUnit.Complexity.COMPOUND) {
int startSlice = 0;
// inclusive
int endSlice = singleUnits.size() - 1;
assert endSlice > 0 : "COMPOUND units have more than one single unit";
if (singleUnits.get(endSlice).getDimensionality() < 0) {
// We have a -per- construct
String perRule = getDeriveCompoundRule(locale, "gender", "per");
if (perRule.length() != 1) {
// Fixed gender for -per- units
return perRule;
}
if (perRule.charAt(0) == '1') {
// Find the start of the denominator. We already know there is one.
while (singleUnits.get(startSlice).getDimensionality() >= 0) {
startSlice++;
}
} else {
// Find the end of the numerator
while (endSlice >= 0 && singleUnits.get(endSlice).getDimensionality() < 0) {
endSlice--;
}
if (endSlice < 0) {
// We have only a denominator, e.g. "per-second".
// TODO(icu-units#28): find out what gender to use in the
// absence of a first value - mentioned in CLDR-14253.
return "";
}
}
}
if (endSlice > startSlice) {
// We have a -times- construct
String timesRule = getDeriveCompoundRule(locale, "gender", "times");
if (timesRule.length() != 1) {
// Fixed gender for -times- units
return timesRule;
}
if (timesRule.charAt(0) == '0') {
endSlice = startSlice;
} else {
// We assume timesRule[0] == u'1'
startSlice = endSlice;
}
}
assert startSlice == endSlice;
singleUnitIndex = startSlice;
} else if (mui.getComplexity() == MeasureUnit.Complexity.MIXED) {
throw new ICUException("calculateGenderForUnit does not support MIXED units");
} else {
assert mui.getComplexity() == MeasureUnit.Complexity.SINGLE;
assert singleUnits.size() == 1;
}
// Now we know which singleUnit's gender we want
SingleUnitImpl singleUnit = singleUnits.get(singleUnitIndex);
// Check for any power-prefix gender override:
if (Math.abs(singleUnit.getDimensionality()) != 1) {
String powerRule = getDeriveCompoundRule(locale, "gender", "power");
if (powerRule.length() != 1) {
// Fixed gender for -powN- units
return powerRule;
}
// powerRule[0] == u'0'; u'1' not currently in spec.
}
// Check for any SI and binary prefix gender override:
if (Math.abs(singleUnit.getDimensionality()) != 1) {
String prefixRule = getDeriveCompoundRule(locale, "gender", "prefix");
if (prefixRule.length() != 1) {
// Fixed gender for -powN- units
return prefixRule;
}
// prefixRule[0] == u'0'; u'1' not currently in spec.
}
// Now we've boiled it down to the gender of one simple unit identifier:
return getGenderForBuiltin(locale, MeasureUnit.forIdentifier(singleUnit.getSimpleUnitID()));
}
private static void maybeCalculateGender(ULocale locale, MeasureUnit unit, String[] outArray) {
if (outArray[GENDER_INDEX] == null) {
String meterGender = getGenderForBuiltin(locale, MeasureUnit.METER);
if (meterGender.isEmpty()) {
// No gender for meter: assume ungendered language
return;
}
// We have a gendered language, but are lacking gender for unitRef.
outArray[GENDER_INDEX] = calculateGenderForUnit(locale, unit);
}
}
private final Map modifiers;
private final PluralRules rules;
private final MicroPropsGenerator parent;
// Grammatical gender of the formatted result.
private String gender = "";
private LongNameHandler(
Map modifiers,
PluralRules rules,
MicroPropsGenerator parent) {
this.modifiers = modifiers;
this.rules = rules;
this.parent = parent;
}
public static String getUnitDisplayName(ULocale locale, MeasureUnit unit, UnitWidth width) {
String[] measureData = new String[ARRAY_LENGTH];
getMeasureData(locale, unit, width, "", measureData);
return measureData[DNAM_INDEX];
}
public static LongNameHandler forCurrencyLongNames(
ULocale locale,
Currency currency,
PluralRules rules,
MicroPropsGenerator parent) {
String[] simpleFormats = new String[ARRAY_LENGTH];
getCurrencyLongNameData(locale, currency, simpleFormats);
// TODO(ICU4J): Reduce the number of object creations here?
Map modifiers = new EnumMap<>(
StandardPlural.class);
LongNameHandler result = new LongNameHandler(modifiers, rules, parent);
result.simpleFormatsToModifiers(simpleFormats, NumberFormat.Field.CURRENCY);
// TODO(icu-units#28): currency gender?
return result;
}
/**
* Construct a localized LongNameHandler for the specified MeasureUnit.
*
* Mixed units are not supported, use MixedUnitLongNameHandler.forMeasureUnit.
*
* @param locale The desired locale.
* @param unit The measure unit to construct a LongNameHandler for.
* @param width Specifies the desired unit rendering.
* @param unitDisplayCase Specifies the desired grammatical case. If the
* specified case is not found, we fall back to nominative or no-case.
* @param rules Plural rules.
* @param parent Plural rules.
*/
public static LongNameHandler forMeasureUnit(
ULocale locale,
MeasureUnit unit,
UnitWidth width,
String unitDisplayCase,
PluralRules rules,
MicroPropsGenerator parent) {
// From https://unicode.org/reports/tr35/tr35-general.html#compound-units -
// Points 1 and 2 are mostly handled by MeasureUnit:
//
// 1. If the unitId is empty or invalid, fail
// 2. Put the unitId into normalized order
if (unit.getType() != null) {
String[] simpleFormats = new String[ARRAY_LENGTH];
getMeasureData(locale, unit, width, unitDisplayCase, simpleFormats);
maybeCalculateGender(locale, unit, simpleFormats);
// TODO(ICU4J): Reduce the number of object creations here?
Map modifiers = new EnumMap<>(StandardPlural.class);
LongNameHandler result = new LongNameHandler(modifiers, rules, parent);
result.simpleFormatsToModifiers(simpleFormats, NumberFormat.Field.MEASURE_UNIT);
if (simpleFormats[GENDER_INDEX] != null) {
result.gender = simpleFormats[GENDER_INDEX];
}
return result;
} else {
assert unit.getComplexity() != Complexity.MIXED
: "Mixed units not supported by LongNameHandler: use MixedUnitLongNameHandler";
return forArbitraryUnit(locale, unit, width, unitDisplayCase, rules, parent);
}
}
private static LongNameHandler forArbitraryUnit(ULocale loc,
MeasureUnit unit,
UnitWidth width,
String unitDisplayCase,
PluralRules rules,
MicroPropsGenerator parent) {
// Numbered list items are from the algorithms at
// https://unicode.org/reports/tr35/tr35-general.html#compound-units:
//
// 4. Divide the unitId into numerator (the part before the "-per-") and
// denominator (the part after the "-per-). If both are empty, fail
MeasureUnitImpl fullUnit = unit.getCopyOfMeasureUnitImpl();
unit = null;
MeasureUnit perUnit = null;
// TODO(icu-units#28): lots of inefficiency in the handling of
// MeasureUnit/MeasureUnitImpl:
for (SingleUnitImpl subUnit : fullUnit.getSingleUnits()) {
if (subUnit.getDimensionality() > 0) {
if (unit == null) {
unit = subUnit.build();
} else {
unit = unit.product(subUnit.build());
}
} else {
// It's okay to mutate fullUnit, we made a temporary copy:
subUnit.setDimensionality(subUnit.getDimensionality() * -1);
if (perUnit == null) {
perUnit = subUnit.build();
} else {
perUnit = perUnit.product(subUnit.build());
}
}
}
MeasureUnitImpl unitImpl = unit == null ? null : unit.getCopyOfMeasureUnitImpl();
MeasureUnitImpl perUnitImpl = perUnit == null ? null : perUnit.getCopyOfMeasureUnitImpl();
// TODO(icu-units#28): check placeholder logic, see if it needs to be
// present here instead of only in processPatternTimes:
//
// 5. Set both globalPlaceholder and globalPlaceholderPosition to be empty
DerivedComponents derivedPerCases = new DerivedComponents(loc, "case", "per");
// 6. numeratorUnitString
String[] numeratorUnitData = new String[ARRAY_LENGTH];
processPatternTimes(unitImpl, loc, width, derivedPerCases.value0(unitDisplayCase),
numeratorUnitData);
// 7. denominatorUnitString
String[] denominatorUnitData = new String[ARRAY_LENGTH];
processPatternTimes(perUnitImpl, loc, width, derivedPerCases.value1(unitDisplayCase),
denominatorUnitData);
// TODO(icu-units#139):
// - implement DerivedComponents for "plural/times" and "plural/power":
// French has different rules, we'll be producing the wrong results
// currently. (Prove via tests!)
// - implement DerivedComponents for "plural/per", "plural/prefix",
// "case/times", "case/power", and "case/prefix" - although they're
// currently hardcoded. Languages with different rules are surely on the
// way.
//
// Currently we only use "case/per", "plural/times", "case/times", and
// "case/power".
//
// This may have impact on multiSimpleFormatsToModifiers(...) below too?
// These rules are currently (ICU 69) all the same and hard-coded below.
String perUnitPattern = null;
if (denominatorUnitData[PER_INDEX] != null) {
// If we have no denominator, we obtain the empty string:
perUnitPattern = denominatorUnitData[PER_INDEX];
} else {
StringBuilder sb = new StringBuilder();
// 8. Set perPattern to be getValue([per], locale, length)
String rawPerUnitFormat = getCompoundValue("per", loc, width);
// rawPerUnitFormat is something like "{0} per {1}"; we need to substitute in the secondary
// unit.
String perPatternFormatter =
SimpleFormatterImpl.compileToStringMinMaxArguments(rawPerUnitFormat, sb, 2, 2);
// Plural and placeholder handling for 7. denominatorUnitString:
// TODO(icu-units#139): hardcoded:
// modifiers = new EnumMap<>(
StandardPlural.class);
LongNameHandler result = new LongNameHandler(modifiers, rules, parent);
if (perUnitPattern.length() == 0) {
result.simpleFormatsToModifiers(numeratorUnitData, NumberFormat.Field.MEASURE_UNIT);
} else {
result.multiSimpleFormatsToModifiers(numeratorUnitData, perUnitPattern,
NumberFormat.Field.MEASURE_UNIT);
}
// Gender
//
// TODO(icu-units#28): find out what gender to use in the absence of a first
// value - e.g. what's the gender of "per-second"? Mentioned in CLDR-14253.
//
// gender/per deriveCompound rules don't say:
// singleUnits = productUnit.getSingleUnits();
for (int singleUnitIndex = 0; singleUnitIndex < singleUnits.size(); singleUnitIndex++) {
SingleUnitImpl singleUnit = singleUnits.get(singleUnitIndex);
String singlePluralCategory;
String singleCaseVariant;
// TODO(icu-units#28): ensure we have unit tests that change/fail if we
// assign incorrect case variants here:
if (singleUnitIndex < singleUnits.size() - 1) {
// 4.1. If hasMultiple
singlePluralCategory = derivedTimesPlurals.value0(pluralCategory);
singleCaseVariant = derivedTimesCases.value0(caseVariant);
pluralCategory = derivedTimesPlurals.value1(pluralCategory);
caseVariant = derivedTimesCases.value1(caseVariant);
} else {
singlePluralCategory = derivedTimesPlurals.value1(pluralCategory);
singleCaseVariant = derivedTimesCases.value1(caseVariant);
}
// 4.2. Get the gender of that single_unit
simpleUnit = MeasureUnit.findBySubType(singleUnit.getSimpleUnitID());
if (simpleUnit == null) {
// Ideally all simple units should be known, but they're not:
// 100-kilometer is internally treated as a simple unit, but it is
// not a built-in unit and does not have formatting data in CLDR 39.
//
// TODO(icu-units#28): test (desirable) invariants in unit tests.
throw new UnsupportedOperationException("Unsupported sinlgeUnit: " +
singleUnit.getSimpleUnitID());
}
String gender = getGenderForBuiltin(loc, simpleUnit);
// 4.3. If singleUnit starts with a dimensionality_prefix, such as 'square-'
assert singleUnit.getDimensionality() > 0;
int dimensionality = singleUnit.getDimensionality();
String[] dimensionalityPrefixPatterns = new String[ARRAY_LENGTH];
if (dimensionality != 1) {
// 4.3.1. set dimensionalityPrefixPattern to be
// getValue(that dimensionality_prefix, locale, length, singlePluralCategory,
// singleCaseVariant, gender), such as "{0} kwadratowym"
StringBuilder dimensionalityKey = new StringBuilder("compound/power");
dimensionalityKey.append(dimensionality);
try {
getInflectedMeasureData(dimensionalityKey.toString(), loc, width, gender,
singleCaseVariant, dimensionalityPrefixPatterns);
} catch (MissingResourceException e) {
// At the time of writing, only pow2 and pow3 are supported.
// Attempting to format other powers results in a
// U_RESOURCE_TYPE_MISMATCH. We convert the error if we
// understand it:
if (dimensionality > 3) {
throw new UnsupportedOperationException("powerN not supported for N > 3: " +
productUnit.getIdentifier());
} else {
throw e;
}
}
// TODO(icu-units#139):
// 4.3.2. set singlePluralCategory to be power0(singlePluralCategory)
// 4.3.3. set singleCaseVariant to be power0(singleCaseVariant)
singleCaseVariant = derivedPowerCases.value0(singleCaseVariant);
// 4.3.4. remove the dimensionality_prefix from singleUnit
singleUnit.setDimensionality(1);
}
// 4.4. if singleUnit starts with an si_prefix, such as 'centi'
MeasurePrefix prefix = singleUnit.getPrefix();
String prefixPattern = "";
if (prefix != MeasurePrefix.ONE) {
// 4.4.1. set siPrefixPattern to be getValue(that si_prefix, locale,
// length), such as "centy{0}"
StringBuilder prefixKey = new StringBuilder();
// prefixKey looks like "1024p3" or "10p-2":
prefixKey.append(prefix.getBase());
prefixKey.append('p');
prefixKey.append(prefix.getPower());
// Contains a pattern like "centy{0}".
prefixPattern = getCompoundValue(prefixKey.toString(), loc, width);
// 4.4.2. set singlePluralCategory to be prefix0(singlePluralCategory)
//
// TODO(icu-units#139): that refers to these rules:
//