1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// © 2022 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
package com.ibm.icu.message2;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import com.ibm.icu.math.BigDecimal;
import com.ibm.icu.number.LocalizedNumberFormatter;
import com.ibm.icu.number.NumberFormatter;
import com.ibm.icu.number.Precision;
import com.ibm.icu.number.UnlocalizedNumberFormatter;
import com.ibm.icu.text.FormattedValue;
import com.ibm.icu.util.CurrencyAmount;
/**
* Creates a {@link Formatter} doing numeric formatting, similar to <code>{exp, number}</code>
* in {@link com.ibm.icu.text.MessageFormat}.
*/
class NumberFormatterFactory implements FormatterFactory {
/**
* {@inheritDoc}
*/
@Override
public Formatter createFormatter(Locale locale, Map<String, Object> fixedOptions) {
return new NumberFormatterImpl(locale, fixedOptions);
}
static class NumberFormatterImpl implements Formatter {
private final Locale locale;
private final Map<String, Object> fixedOptions;
private final LocalizedNumberFormatter icuFormatter;
final boolean advanced;
private static LocalizedNumberFormatter formatterForOptions(Locale locale, Map<String, Object> fixedOptions) {
UnlocalizedNumberFormatter nf;
String skeleton = OptUtils.getString(fixedOptions, "skeleton");
if (skeleton != null) {
nf = NumberFormatter.forSkeleton(skeleton);
} else {
nf = NumberFormatter.with();
Integer minFractionDigits = OptUtils.getInteger(fixedOptions, "minimumFractionDigits");
if (minFractionDigits != null) {
nf = nf.precision(Precision.minFraction(minFractionDigits));
}
}
return nf.locale(locale);
}
NumberFormatterImpl(Locale locale, Map<String, Object> fixedOptions) {
this.locale = locale;
this.fixedOptions = new HashMap<>(fixedOptions);
String skeleton = OptUtils.getString(fixedOptions, "skeleton");
boolean fancy = skeleton != null;
this.icuFormatter = formatterForOptions(locale, fixedOptions);
this.advanced = fancy;
}
LocalizedNumberFormatter getIcuFormatter() {
return icuFormatter;
}
/**
* {@inheritDoc}
*/
@Override
public String formatToString(Object toFormat, Map<String, Object> variableOptions) {
return format(toFormat, variableOptions).toString();
}
/**
* {@inheritDoc}
*/
@Override
public FormattedPlaceholder format(Object toFormat, Map<String, Object> variableOptions) {
LocalizedNumberFormatter realFormatter;
if (variableOptions.isEmpty()) {
realFormatter = this.icuFormatter;
} else {
Map<String, Object> mergedOptions = new HashMap<>(fixedOptions);
mergedOptions.putAll(variableOptions);
// This is really wasteful, as we don't use the existing
// formatter if even one option is variable.
// We can optimize, but for now will have to do.
realFormatter = formatterForOptions(locale, mergedOptions);
}
Integer offset = OptUtils.getInteger(variableOptions, "offset");
if (offset == null && fixedOptions != null) {
offset = OptUtils.getInteger(fixedOptions, "offset");
}
if (offset == null) {
offset = 0;
}
FormattedValue result = null;
if (toFormat == null) {
// This is also what MessageFormat does.
throw new NullPointerException("Argument to format can't be null");
} else if (toFormat instanceof Double) {
result = realFormatter.format((double) toFormat - offset);
} else if (toFormat instanceof Long) {
result = realFormatter.format((long) toFormat - offset);
} else if (toFormat instanceof Integer) {
result = realFormatter.format((int) toFormat - offset);
} else if (toFormat instanceof BigDecimal) {
BigDecimal bd = (BigDecimal) toFormat;
result = realFormatter.format(bd.subtract(BigDecimal.valueOf(offset)));
} else if (toFormat instanceof Number) {
result = realFormatter.format(((Number) toFormat).doubleValue() - offset);
} else if (toFormat instanceof CurrencyAmount) {
result = realFormatter.format((CurrencyAmount) toFormat);
} else {
// The behavior is not in the spec, will be in the registry.
// We can return "NaN", or try to parse the string as a number
String strValue = Objects.toString(toFormat);
Number nrValue = OptUtils.asNumber(strValue);
if (nrValue != null) {
result = realFormatter.format(nrValue.doubleValue() - offset);
} else {
result = new PlainStringFormattedValue("NaN");
}
}
return new FormattedPlaceholder(toFormat, result);
}
}
}
|
