NumberFormatterImpl.java
// © 2017 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
package com.ibm.icu.number;
import com.ibm.icu.impl.FormattedStringBuilder;
import com.ibm.icu.impl.IllegalIcuArgumentException;
import com.ibm.icu.impl.StandardPlural;
import com.ibm.icu.impl.number.AffixPatternProvider;
import com.ibm.icu.impl.number.CompactData.CompactType;
import com.ibm.icu.impl.number.ConstantAffixModifier;
import com.ibm.icu.impl.number.DecimalQuantity;
import com.ibm.icu.impl.number.DecimalQuantity_DualStorageBCD;
import com.ibm.icu.impl.number.Grouper;
import com.ibm.icu.impl.number.LongNameHandler;
import com.ibm.icu.impl.number.LongNameMultiplexer;
import com.ibm.icu.impl.number.MacroProps;
import com.ibm.icu.impl.number.MicroProps;
import com.ibm.icu.impl.number.MicroPropsGenerator;
import com.ibm.icu.impl.number.MixedUnitLongNameHandler;
import com.ibm.icu.impl.number.MultiplierFormatHandler;
import com.ibm.icu.impl.number.MutablePatternModifier;
import com.ibm.icu.impl.number.MutablePatternModifier.ImmutablePatternModifier;
import com.ibm.icu.impl.number.Padder;
import com.ibm.icu.impl.number.PatternStringParser;
import com.ibm.icu.impl.number.PatternStringParser.ParsedPatternInfo;
import com.ibm.icu.impl.number.RoundingUtils;
import com.ibm.icu.impl.number.UnitConversionHandler;
import com.ibm.icu.impl.number.UsagePrefsHandler;
import com.ibm.icu.number.NumberFormatter.DecimalSeparatorDisplay;
import com.ibm.icu.number.NumberFormatter.GroupingStrategy;
import com.ibm.icu.number.NumberFormatter.SignDisplay;
import com.ibm.icu.number.NumberFormatter.UnitWidth;
import com.ibm.icu.text.DecimalFormatSymbols;
import com.ibm.icu.text.NumberFormat;
import com.ibm.icu.text.NumberingSystem;
import com.ibm.icu.text.PluralRules;
import com.ibm.icu.util.Currency;
import com.ibm.icu.util.MeasureUnit;
/**
* This is the "brain" of the number formatting pipeline. It ties all the pieces together, taking in
* a MacroProps and a DecimalQuantity and outputting a properly formatted number string.
*
* <p>This class, as well as NumberPropertyMapper, could go into the impl package, but they depend
* on too many package-private members of the public APIs.
*/
class NumberFormatterImpl {
/** Builds a "safe" MicroPropsGenerator, which is thread-safe and can be used repeatedly. */
public NumberFormatterImpl(MacroProps macros) {
micros = new MicroProps(true);
microPropsGenerator = macrosToMicroGenerator(macros, micros, true);
}
/**
* Builds and evaluates an "unsafe" MicroPropsGenerator, which is cheaper but can be used only
* once.
*/
public static MicroProps formatStatic(
MacroProps macros, DecimalQuantity inValue, FormattedStringBuilder outString) {
MicroProps result = preProcessUnsafe(macros, inValue);
int length = writeNumber(result, inValue, outString, 0);
writeAffixes(result, outString, 0, length);
return result;
}
/**
* Prints only the prefix and suffix; used for DecimalFormat getters.
*
* @return The index into the output at which the prefix ends and the suffix starts; in other
* words, the prefix length.
*/
public static int getPrefixSuffixStatic(
MacroProps macros, byte signum, StandardPlural plural, FormattedStringBuilder output) {
MicroProps micros = new MicroProps(false);
MicroPropsGenerator microPropsGenerator = macrosToMicroGenerator(macros, micros, false);
return getPrefixSuffixImpl(microPropsGenerator, signum, output);
}
private static final Currency DEFAULT_CURRENCY = Currency.getInstance("XXX");
final MicroProps micros;
final MicroPropsGenerator microPropsGenerator;
/** Evaluates the "safe" MicroPropsGenerator created by "fromMacros". */
public MicroProps format(DecimalQuantity inValue, FormattedStringBuilder outString) {
MicroProps result = preProcess(inValue);
int length = writeNumber(result, inValue, outString, 0);
writeAffixes(result, outString, 0, length);
return result;
}
/**
* Like format(), but saves the result into an output MicroProps without additional processing.
*/
public MicroProps preProcess(DecimalQuantity inValue) {
MicroProps micros = microPropsGenerator.processQuantity(inValue);
if (micros.integerWidth.maxInt == -1) {
inValue.setMinInteger(micros.integerWidth.minInt);
} else {
inValue.setMinInteger(micros.integerWidth.minInt);
inValue.applyMaxInteger(micros.integerWidth.maxInt);
}
return micros;
}
private static MicroProps preProcessUnsafe(MacroProps macros, DecimalQuantity inValue) {
MicroProps micros = new MicroProps(false);
MicroPropsGenerator microPropsGenerator = macrosToMicroGenerator(macros, micros, false);
micros = microPropsGenerator.processQuantity(inValue);
if (micros.integerWidth.maxInt == -1) {
inValue.setMinInteger(micros.integerWidth.minInt);
} else {
inValue.setMinInteger(micros.integerWidth.minInt);
inValue.applyMaxInteger(micros.integerWidth.maxInt);
}
return micros;
}
public int getPrefixSuffix(byte signum, StandardPlural plural, FormattedStringBuilder output) {
return getPrefixSuffixImpl(microPropsGenerator, signum, output);
}
private static int getPrefixSuffixImpl(
MicroPropsGenerator generator, byte signum, FormattedStringBuilder output) {
// #13453: DecimalFormat wants the affixes from the pattern only (modMiddle).
// TODO: Clean this up, closer to C++. The pattern modifier is not as accessible as in C++.
// Right now, ignore the plural form, run the pipeline with number 0, and get the modifier
// from the result.
DecimalQuantity_DualStorageBCD quantity = new DecimalQuantity_DualStorageBCD(0);
if (signum < 0) {
quantity.negate();
}
MicroProps micros = generator.processQuantity(quantity);
micros.modMiddle.apply(output, 0, 0);
return micros.modMiddle.getPrefixLength();
}
public MicroProps getRawMicroProps() {
return micros;
}
//////////
private static boolean unitIsCurrency(MeasureUnit unit) {
// TODO: Check using "instanceof" operator instead?
return unit != null && "currency".equals(unit.getType());
}
private static boolean unitIsBaseUnit(MeasureUnit unit) {
return unit == null;
}
private static boolean unitIsPercent(MeasureUnit unit) {
return unit != null && "percent".equals(unit.getSubtype());
}
private static boolean unitIsPermille(MeasureUnit unit) {
return unit != null && "permille".equals(unit.getSubtype());
}
/**
* Synthesizes the MacroProps into a MicroPropsGenerator. All information, including the locale,
* is encoded into the MicroPropsGenerator, except for the quantity itself, which is left
* abstract and must be provided to the returned MicroPropsGenerator instance.
*
* @see MicroPropsGenerator
* @param macros The {@link MacroProps} to consume. This method does not mutate the MacroProps
* instance.
* @param safe If true, the returned MicroPropsGenerator will be thread-safe. If false, the
* returned value will <em>not</em> be thread-safe, intended for a single "one-shot" use
* only. Building the thread-safe object is more expensive.
*/
private static MicroPropsGenerator macrosToMicroGenerator(
MacroProps macros, MicroProps micros, boolean safe) {
MicroPropsGenerator chain = micros;
// TODO: Normalize the currency (accept symbols from DecimalFormatSymbols)?
// currency = CustomSymbolCurrency.resolve(currency, input.loc, micros.symbols);
// Pre-compute a few values for efficiency.
boolean isCurrency = unitIsCurrency(macros.unit);
boolean isBaseUnit = unitIsBaseUnit(macros.unit);
boolean isPercent = unitIsPercent(macros.unit);
boolean isPermille = unitIsPermille(macros.unit);
boolean isCompactNotation = (macros.notation instanceof CompactNotation);
boolean isAccounting =
macros.sign == SignDisplay.ACCOUNTING
|| macros.sign == SignDisplay.ACCOUNTING_ALWAYS
|| macros.sign == SignDisplay.ACCOUNTING_EXCEPT_ZERO
|| macros.sign == SignDisplay.ACCOUNTING_NEGATIVE;
Currency currency = isCurrency ? (Currency) macros.unit : DEFAULT_CURRENCY;
UnitWidth unitWidth = UnitWidth.SHORT;
if (macros.unitWidth != null) {
unitWidth = macros.unitWidth;
}
// Use CLDR unit data for all MeasureUnits (not currency and not
// no-unit), except use the dedicated percent pattern for percent and
// permille. However, use the CLDR unit data for percent/permille if a
// long name was requested OR if compact notation is being used, since
// compact notation overrides the middle modifier (micros.modMiddle)
// normally used for the percent pattern.
boolean isCldrUnit =
!isCurrency
&& !isBaseUnit
&& (unitWidth == UnitWidth.FULL_NAME
|| !(isPercent || isPermille)
|| isCompactNotation);
boolean isMixedUnit =
isCldrUnit
&& macros.unit.getType() == null
&& macros.unit.getComplexity() == MeasureUnit.Complexity.MIXED;
PluralRules rules = macros.rules;
// Select the numbering system.
NumberingSystem ns;
if (macros.symbols instanceof NumberingSystem) {
ns = (NumberingSystem) macros.symbols;
} else {
// TODO: Is there a way to avoid creating the NumberingSystem object?
ns = NumberingSystem.getInstance(macros.loc);
}
micros.nsName = ns.getName();
// Default gender: none.
micros.gender = "";
// Resolve the symbols. Do this here because currency may need to customize them.
if (macros.symbols instanceof DecimalFormatSymbols) {
micros.symbols = (DecimalFormatSymbols) macros.symbols;
} else {
micros.symbols = DecimalFormatSymbols.forNumberingSystem(macros.loc, ns);
if (isCurrency) {
micros.symbols.setCurrency(currency);
}
}
// Load and parse the pattern string. It is used for grouping sizes and affixes only.
// If we are formatting currency, check for a currency-specific pattern.
String pattern = null;
if (isCurrency && micros.symbols.getCurrencyPattern() != null) {
pattern = micros.symbols.getCurrencyPattern();
}
if (pattern == null) {
int patternStyle;
if (isCldrUnit) {
patternStyle = NumberFormat.NUMBERSTYLE;
} else if (isPercent || isPermille) {
patternStyle = NumberFormat.PERCENTSTYLE;
} else if (!isCurrency || unitWidth == UnitWidth.FULL_NAME) {
patternStyle = NumberFormat.NUMBERSTYLE;
} else if (isAccounting) {
// NOTE: Although ACCOUNTING and ACCOUNTING_ALWAYS are only supported in currencies
// right now, the API contract allows us to add support to other units in the
// future.
patternStyle = NumberFormat.ACCOUNTINGCURRENCYSTYLE;
} else {
patternStyle = NumberFormat.CURRENCYSTYLE;
}
pattern =
NumberFormat.getPatternForStyleAndNumberingSystem(
macros.loc, micros.nsName, patternStyle);
}
ParsedPatternInfo patternInfo = PatternStringParser.parseToPatternInfo(pattern);
/////////////////////////////////////////////////////////////////////////////////////
/// START POPULATING THE DEFAULT MICROPROPS AND BUILDING THE MICROPROPS GENERATOR ///
/////////////////////////////////////////////////////////////////////////////////////
// Unit Preferences and Conversions as our first step
UsagePrefsHandler usagePrefsHandler = null;
if (macros.usage != null) {
if (!isCldrUnit) {
throw new IllegalIcuArgumentException(
"We only support \"usage\" when the input unit is specified, and is a CLDR Unit.");
}
chain =
usagePrefsHandler =
new UsagePrefsHandler(macros.loc, macros.unit, macros.usage, chain);
} else if (isMixedUnit) {
chain = new UnitConversionHandler(macros.unit, chain);
}
// Multiplier
if (macros.scale != null) {
chain = new MultiplierFormatHandler(macros.scale, chain);
}
// Rounding strategy
if (macros.precision != null) {
micros.rounder = macros.precision;
} else if (isCompactNotation) {
micros.rounder = Precision.COMPACT_STRATEGY;
} else if (isCurrency) {
micros.rounder = Precision.MONETARY_STANDARD;
} else if (macros.usage != null) {
// Bogus Precision - it will get set in the UsagePrefsHandler instead
micros.rounder = Precision.BOGUS_PRECISION;
} else {
micros.rounder = Precision.DEFAULT_MAX_FRAC_6;
}
if (macros.roundingMode != null) {
micros.rounder =
micros.rounder.withMode(
RoundingUtils.mathContextUnlimited(macros.roundingMode));
}
micros.rounder = micros.rounder.withLocaleData(currency);
// Grouping strategy
if (macros.grouping instanceof Grouper) {
micros.grouping = (Grouper) macros.grouping;
} else if (macros.grouping instanceof GroupingStrategy) {
micros.grouping = Grouper.forStrategy((GroupingStrategy) macros.grouping);
} else if (isCompactNotation) {
// Compact notation uses minGrouping by default since ICU 59
micros.grouping = Grouper.forStrategy(GroupingStrategy.MIN2);
} else {
micros.grouping = Grouper.forStrategy(GroupingStrategy.AUTO);
}
micros.grouping = micros.grouping.withLocaleData(macros.loc, patternInfo);
// Padding strategy
if (macros.padder != null) {
micros.padding = macros.padder;
} else {
micros.padding = Padder.NONE;
}
// Integer width
if (macros.integerWidth != null) {
micros.integerWidth = macros.integerWidth;
} else {
micros.integerWidth = IntegerWidth.DEFAULT;
}
// Sign display
if (macros.sign != null) {
micros.sign = macros.sign;
} else {
micros.sign = SignDisplay.AUTO;
}
// Decimal mark display
if (macros.decimal != null) {
micros.decimal = macros.decimal;
} else {
micros.decimal = DecimalSeparatorDisplay.AUTO;
}
// Use monetary separator symbols
micros.useCurrency = isCurrency;
// Inner modifier (scientific notation)
if (macros.notation instanceof ScientificNotation) {
chain =
((ScientificNotation) macros.notation)
.withLocaleData(micros.symbols, safe, chain);
} else {
// No inner modifier required
micros.modInner = ConstantAffixModifier.EMPTY;
}
// Middle modifier (patterns, positive/negative, currency symbols, percent)
// The default middle modifier is weak (thus the false argument).
MutablePatternModifier patternMod = new MutablePatternModifier(false);
AffixPatternProvider affixProvider =
(macros.affixProvider != null
&& (
// For more information on this condition, see ICU-22073
!isCompactNotation
|| isCurrency == macros.affixProvider.hasCurrencySign()))
? macros.affixProvider
: patternInfo;
patternMod.setPatternInfo(affixProvider, null);
boolean approximately = (macros.approximately != null) ? macros.approximately : false;
patternMod.setPatternAttributes(micros.sign, isPermille, approximately);
if (patternMod.needsPlurals()) {
if (rules == null) {
// Lazily create PluralRules
rules = PluralRules.forLocale(macros.loc);
}
patternMod.setSymbols(micros.symbols, currency, unitWidth, rules);
} else {
patternMod.setSymbols(micros.symbols, currency, unitWidth, null);
}
ImmutablePatternModifier immPatternMod = null;
if (safe) {
immPatternMod = patternMod.createImmutable();
}
// currencyAsDecimal
if (affixProvider.currencyAsDecimal()) {
micros.currencyAsDecimal = patternMod.getCurrencySymbolForUnitWidth();
}
// Outer modifier (CLDR units and currency long names)
if (isCldrUnit) {
String unitDisplayCase = null;
if (macros.unitDisplayCase != null) {
unitDisplayCase = macros.unitDisplayCase;
}
if (rules == null) {
// Lazily create PluralRules
rules = PluralRules.forLocale(macros.loc);
}
PluralRules pluralRules =
macros.rules != null ? macros.rules : PluralRules.forLocale(macros.loc);
if (macros.usage != null) {
assert usagePrefsHandler != null;
chain =
LongNameMultiplexer.forMeasureUnits(
macros.loc,
usagePrefsHandler.getOutputUnits(),
unitWidth,
unitDisplayCase,
pluralRules,
chain);
} else if (isMixedUnit) {
chain =
MixedUnitLongNameHandler.forMeasureUnit(
macros.loc,
macros.unit,
unitWidth,
unitDisplayCase,
pluralRules,
chain);
} else {
MeasureUnit unit = macros.unit;
if (macros.perUnit != null) {
unit = unit.product(macros.perUnit.reciprocal());
// This isn't strictly necessary, but was what we specced
// out when perUnit became a backward-compatibility thing:
// unit/perUnit use case is only valid if both units are
// built-ins, or the product is a built-in.
if (unit.getType() == null
&& (macros.unit.getType() == null
|| macros.perUnit.getType() == null)) {
throw new UnsupportedOperationException(
"perUnit() can only be used if unit and perUnit are both built-ins, or the combination is a built-in");
}
}
chain =
LongNameHandler.forMeasureUnit(
macros.loc, unit, unitWidth, unitDisplayCase, pluralRules, chain);
}
} else if (isCurrency && unitWidth == UnitWidth.FULL_NAME) {
if (rules == null) {
// Lazily create PluralRules
rules = PluralRules.forLocale(macros.loc);
}
chain = LongNameHandler.forCurrencyLongNames(macros.loc, currency, rules, chain);
} else {
// No outer modifier required
micros.modOuter = ConstantAffixModifier.EMPTY;
}
// Compact notation
if (isCompactNotation) {
if (rules == null) {
// Lazily create PluralRules
rules = PluralRules.forLocale(macros.loc);
}
CompactType compactType =
(macros.unit instanceof Currency && macros.unitWidth != UnitWidth.FULL_NAME)
? CompactType.CURRENCY
: CompactType.DECIMAL;
chain =
((CompactNotation) macros.notation)
.withLocaleData(
macros.loc,
micros.nsName,
compactType,
rules,
patternMod,
safe,
chain);
}
// Always add the pattern modifier as the last element of the chain.
if (safe) {
chain = immPatternMod.addToChain(chain);
} else {
chain = patternMod.addToChain(chain);
}
return chain;
}
//////////
/** Adds the affixes. Intended to be called immediately after formatNumber. */
public static int writeAffixes(
MicroProps micros, FormattedStringBuilder string, int start, int end) {
// Always apply the inner modifier (which is "strong").
int length = micros.modInner.apply(string, start, end);
if (micros.padding.isValid()) {
micros.padding.padAndApply(
micros.modMiddle, micros.modOuter, string, start, end + length);
} else {
length += micros.modMiddle.apply(string, start, end + length);
length += micros.modOuter.apply(string, start, end + length);
}
return length;
}
/**
* Synthesizes the output string from a MicroProps and DecimalQuantity. This method formats only
* the main number, not affixes.
*/
public static int writeNumber(
MicroProps micros, DecimalQuantity quantity, FormattedStringBuilder string, int index) {
int length = 0;
if (quantity.isInfinite()) {
length +=
string.insert(
length + index,
micros.symbols.getInfinity(),
NumberFormat.Field.INTEGER);
} else if (quantity.isNaN()) {
length +=
string.insert(
length + index, micros.symbols.getNaN(), NumberFormat.Field.INTEGER);
} else {
// Add the integer digits
length += writeIntegerDigits(micros, quantity, string, length + index);
// Add the decimal point
if (quantity.getLowerDisplayMagnitude() < 0
|| micros.decimal == DecimalSeparatorDisplay.ALWAYS) {
if (micros.currencyAsDecimal != null) {
// Note: This unconditionally substitutes the standard short symbol.
// TODO: Should we support narrow or other variants?
length +=
string.insert(
length + index,
micros.currencyAsDecimal,
NumberFormat.Field.CURRENCY);
} else if (micros.useCurrency) {
length +=
string.insert(
length + index,
micros.symbols.getMonetaryDecimalSeparatorString(),
NumberFormat.Field.DECIMAL_SEPARATOR);
} else {
length +=
string.insert(
length + index,
micros.symbols.getDecimalSeparatorString(),
NumberFormat.Field.DECIMAL_SEPARATOR);
}
}
// Add the fraction digits
length += writeFractionDigits(micros, quantity, string, length + index);
if (length == 0) {
// Force output of the digit for value 0
if (micros.symbols.getCodePointZero() != -1) {
length +=
string.insertCodePoint(
index,
micros.symbols.getCodePointZero(),
NumberFormat.Field.INTEGER);
} else {
length +=
string.insert(
index,
micros.symbols.getDigitStringsLocal()[0],
NumberFormat.Field.INTEGER);
}
}
}
return length;
}
private static int writeIntegerDigits(
MicroProps micros, DecimalQuantity quantity, FormattedStringBuilder string, int index) {
int length = 0;
int integerCount = quantity.getUpperDisplayMagnitude() + 1;
for (int i = 0; i < integerCount; i++) {
// Add grouping separator
if (micros.grouping.groupAtPosition(i, quantity)) {
length +=
string.insert(
index,
micros.useCurrency
? micros.symbols.getMonetaryGroupingSeparatorString()
: micros.symbols.getGroupingSeparatorString(),
NumberFormat.Field.GROUPING_SEPARATOR);
}
// Get and append the next digit value
byte nextDigit = quantity.getDigit(i);
if (micros.symbols.getCodePointZero() != -1) {
length +=
string.insertCodePoint(
index,
micros.symbols.getCodePointZero() + nextDigit,
NumberFormat.Field.INTEGER);
} else {
length +=
string.insert(
index,
micros.symbols.getDigitStringsLocal()[nextDigit],
NumberFormat.Field.INTEGER);
}
}
return length;
}
private static int writeFractionDigits(
MicroProps micros, DecimalQuantity quantity, FormattedStringBuilder string, int index) {
int length = 0;
int fractionCount = -quantity.getLowerDisplayMagnitude();
for (int i = 0; i < fractionCount; i++) {
// Get and append the next digit value
byte nextDigit = quantity.getDigit(-i - 1);
if (micros.symbols.getCodePointZero() != -1) {
length +=
string.insertCodePoint(
length + index,
micros.symbols.getCodePointZero() + nextDigit,
NumberFormat.Field.FRACTION);
} else {
length +=
string.insert(
length + index,
micros.symbols.getDigitStringsLocal()[nextDigit],
NumberFormat.Field.FRACTION);
}
}
return length;
}
}