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 "uassert.h"
9 #include "unicode/numberformatter.h"
10 #include "number_decimalquantity.h"
11 #include "number_formatimpl.h"
12 #include "umutex.h"
13 #include "number_asformat.h"
14 #include "number_skeletons.h"
15 #include "number_utils.h"
16 #include "number_utypes.h"
17 #include "util.h"
18 #include "fphdlimp.h"
19
20 using namespace icu;
21 using namespace icu::number;
22 using namespace icu::number::impl;
23
24 template<typename Derived>
notation(const Notation & notation) const25 Derived NumberFormatterSettings<Derived>::notation(const Notation& notation) const& {
26 Derived copy(*this);
27 // NOTE: Slicing is OK.
28 copy.fMacros.notation = notation;
29 return copy;
30 }
31
32 template<typename Derived>
notation(const Notation & notation)33 Derived NumberFormatterSettings<Derived>::notation(const Notation& notation)&& {
34 Derived move(std::move(*this));
35 // NOTE: Slicing is OK.
36 move.fMacros.notation = notation;
37 return move;
38 }
39
40 template<typename Derived>
unit(const icu::MeasureUnit & unit) const41 Derived NumberFormatterSettings<Derived>::unit(const icu::MeasureUnit& unit) const& {
42 Derived copy(*this);
43 // NOTE: Slicing occurs here. However, CurrencyUnit can be restored from MeasureUnit.
44 // TimeUnit may be affected, but TimeUnit is not as relevant to number formatting.
45 copy.fMacros.unit = unit;
46 return copy;
47 }
48
49 template<typename Derived>
unit(const icu::MeasureUnit & unit)50 Derived NumberFormatterSettings<Derived>::unit(const icu::MeasureUnit& unit)&& {
51 Derived move(std::move(*this));
52 // See comments above about slicing.
53 move.fMacros.unit = unit;
54 return move;
55 }
56
57 template<typename Derived>
adoptUnit(icu::MeasureUnit * unit) const58 Derived NumberFormatterSettings<Derived>::adoptUnit(icu::MeasureUnit* unit) const& {
59 Derived copy(*this);
60 // Just move the unit into the MacroProps by value, and delete it since we have ownership.
61 // NOTE: Slicing occurs here. However, CurrencyUnit can be restored from MeasureUnit.
62 // TimeUnit may be affected, but TimeUnit is not as relevant to number formatting.
63 if (unit != nullptr) {
64 // TODO: On nullptr, reset to default value?
65 copy.fMacros.unit = std::move(*unit);
66 delete unit;
67 }
68 return copy;
69 }
70
71 template<typename Derived>
adoptUnit(icu::MeasureUnit * unit)72 Derived NumberFormatterSettings<Derived>::adoptUnit(icu::MeasureUnit* unit)&& {
73 Derived move(std::move(*this));
74 // See comments above about slicing and ownership.
75 if (unit != nullptr) {
76 // TODO: On nullptr, reset to default value?
77 move.fMacros.unit = std::move(*unit);
78 delete unit;
79 }
80 return move;
81 }
82
83 template<typename Derived>
perUnit(const icu::MeasureUnit & perUnit) const84 Derived NumberFormatterSettings<Derived>::perUnit(const icu::MeasureUnit& perUnit) const& {
85 Derived copy(*this);
86 // See comments above about slicing.
87 copy.fMacros.perUnit = perUnit;
88 return copy;
89 }
90
91 template<typename Derived>
perUnit(const icu::MeasureUnit & perUnit)92 Derived NumberFormatterSettings<Derived>::perUnit(const icu::MeasureUnit& perUnit)&& {
93 Derived move(std::move(*this));
94 // See comments above about slicing.
95 move.fMacros.perUnit = perUnit;
96 return move;
97 }
98
99 template<typename Derived>
adoptPerUnit(icu::MeasureUnit * perUnit) const100 Derived NumberFormatterSettings<Derived>::adoptPerUnit(icu::MeasureUnit* perUnit) const& {
101 Derived copy(*this);
102 // See comments above about slicing and ownership.
103 if (perUnit != nullptr) {
104 // TODO: On nullptr, reset to default value?
105 copy.fMacros.perUnit = std::move(*perUnit);
106 delete perUnit;
107 }
108 return copy;
109 }
110
111 template<typename Derived>
adoptPerUnit(icu::MeasureUnit * perUnit)112 Derived NumberFormatterSettings<Derived>::adoptPerUnit(icu::MeasureUnit* perUnit)&& {
113 Derived move(std::move(*this));
114 // See comments above about slicing and ownership.
115 if (perUnit != nullptr) {
116 // TODO: On nullptr, reset to default value?
117 move.fMacros.perUnit = std::move(*perUnit);
118 delete perUnit;
119 }
120 return move;
121 }
122
123 template<typename Derived>
precision(const Precision & precision) const124 Derived NumberFormatterSettings<Derived>::precision(const Precision& precision) const& {
125 Derived copy(*this);
126 // NOTE: Slicing is OK.
127 copy.fMacros.precision = precision;
128 return copy;
129 }
130
131 template<typename Derived>
precision(const Precision & precision)132 Derived NumberFormatterSettings<Derived>::precision(const Precision& precision)&& {
133 Derived move(std::move(*this));
134 // NOTE: Slicing is OK.
135 move.fMacros.precision = precision;
136 return move;
137 }
138
139 template<typename Derived>
roundingMode(UNumberFormatRoundingMode roundingMode) const140 Derived NumberFormatterSettings<Derived>::roundingMode(UNumberFormatRoundingMode roundingMode) const& {
141 Derived copy(*this);
142 copy.fMacros.roundingMode = roundingMode;
143 return copy;
144 }
145
146 template<typename Derived>
roundingMode(UNumberFormatRoundingMode roundingMode)147 Derived NumberFormatterSettings<Derived>::roundingMode(UNumberFormatRoundingMode roundingMode)&& {
148 Derived move(std::move(*this));
149 move.fMacros.roundingMode = roundingMode;
150 return move;
151 }
152
153 template<typename Derived>
grouping(UGroupingStrategy strategy) const154 Derived NumberFormatterSettings<Derived>::grouping(UGroupingStrategy strategy) const& {
155 Derived copy(*this);
156 // NOTE: This is slightly different than how the setting is stored in Java
157 // because we want to put it on the stack.
158 copy.fMacros.grouper = Grouper::forStrategy(strategy);
159 return copy;
160 }
161
162 template<typename Derived>
grouping(UGroupingStrategy strategy)163 Derived NumberFormatterSettings<Derived>::grouping(UGroupingStrategy strategy)&& {
164 Derived move(std::move(*this));
165 move.fMacros.grouper = Grouper::forStrategy(strategy);
166 return move;
167 }
168
169 template<typename Derived>
integerWidth(const IntegerWidth & style) const170 Derived NumberFormatterSettings<Derived>::integerWidth(const IntegerWidth& style) const& {
171 Derived copy(*this);
172 copy.fMacros.integerWidth = style;
173 return copy;
174 }
175
176 template<typename Derived>
integerWidth(const IntegerWidth & style)177 Derived NumberFormatterSettings<Derived>::integerWidth(const IntegerWidth& style)&& {
178 Derived move(std::move(*this));
179 move.fMacros.integerWidth = style;
180 return move;
181 }
182
183 template<typename Derived>
symbols(const DecimalFormatSymbols & symbols) const184 Derived NumberFormatterSettings<Derived>::symbols(const DecimalFormatSymbols& symbols) const& {
185 Derived copy(*this);
186 copy.fMacros.symbols.setTo(symbols);
187 return copy;
188 }
189
190 template<typename Derived>
symbols(const DecimalFormatSymbols & symbols)191 Derived NumberFormatterSettings<Derived>::symbols(const DecimalFormatSymbols& symbols)&& {
192 Derived move(std::move(*this));
193 move.fMacros.symbols.setTo(symbols);
194 return move;
195 }
196
197 template<typename Derived>
adoptSymbols(NumberingSystem * ns) const198 Derived NumberFormatterSettings<Derived>::adoptSymbols(NumberingSystem* ns) const& {
199 Derived copy(*this);
200 copy.fMacros.symbols.setTo(ns);
201 return copy;
202 }
203
204 template<typename Derived>
adoptSymbols(NumberingSystem * ns)205 Derived NumberFormatterSettings<Derived>::adoptSymbols(NumberingSystem* ns)&& {
206 Derived move(std::move(*this));
207 move.fMacros.symbols.setTo(ns);
208 return move;
209 }
210
211 template<typename Derived>
unitWidth(UNumberUnitWidth width) const212 Derived NumberFormatterSettings<Derived>::unitWidth(UNumberUnitWidth width) const& {
213 Derived copy(*this);
214 copy.fMacros.unitWidth = width;
215 return copy;
216 }
217
218 template<typename Derived>
unitWidth(UNumberUnitWidth width)219 Derived NumberFormatterSettings<Derived>::unitWidth(UNumberUnitWidth width)&& {
220 Derived move(std::move(*this));
221 move.fMacros.unitWidth = width;
222 return move;
223 }
224
225 template<typename Derived>
sign(UNumberSignDisplay style) const226 Derived NumberFormatterSettings<Derived>::sign(UNumberSignDisplay style) const& {
227 Derived copy(*this);
228 copy.fMacros.sign = style;
229 return copy;
230 }
231
232 template<typename Derived>
sign(UNumberSignDisplay style)233 Derived NumberFormatterSettings<Derived>::sign(UNumberSignDisplay style)&& {
234 Derived move(std::move(*this));
235 move.fMacros.sign = style;
236 return move;
237 }
238
239 template<typename Derived>
decimal(UNumberDecimalSeparatorDisplay style) const240 Derived NumberFormatterSettings<Derived>::decimal(UNumberDecimalSeparatorDisplay style) const& {
241 Derived copy(*this);
242 copy.fMacros.decimal = style;
243 return copy;
244 }
245
246 template<typename Derived>
decimal(UNumberDecimalSeparatorDisplay style)247 Derived NumberFormatterSettings<Derived>::decimal(UNumberDecimalSeparatorDisplay style)&& {
248 Derived move(std::move(*this));
249 move.fMacros.decimal = style;
250 return move;
251 }
252
253 template<typename Derived>
scale(const Scale & scale) const254 Derived NumberFormatterSettings<Derived>::scale(const Scale& scale) const& {
255 Derived copy(*this);
256 copy.fMacros.scale = scale;
257 return copy;
258 }
259
260 template<typename Derived>
scale(const Scale & scale)261 Derived NumberFormatterSettings<Derived>::scale(const Scale& scale)&& {
262 Derived move(std::move(*this));
263 move.fMacros.scale = scale;
264 return move;
265 }
266
267 template<typename Derived>
padding(const Padder & padder) const268 Derived NumberFormatterSettings<Derived>::padding(const Padder& padder) const& {
269 Derived copy(*this);
270 copy.fMacros.padder = padder;
271 return copy;
272 }
273
274 template<typename Derived>
padding(const Padder & padder)275 Derived NumberFormatterSettings<Derived>::padding(const Padder& padder)&& {
276 Derived move(std::move(*this));
277 move.fMacros.padder = padder;
278 return move;
279 }
280
281 template<typename Derived>
threshold(int32_t threshold) const282 Derived NumberFormatterSettings<Derived>::threshold(int32_t threshold) const& {
283 Derived copy(*this);
284 copy.fMacros.threshold = threshold;
285 return copy;
286 }
287
288 template<typename Derived>
threshold(int32_t threshold)289 Derived NumberFormatterSettings<Derived>::threshold(int32_t threshold)&& {
290 Derived move(std::move(*this));
291 move.fMacros.threshold = threshold;
292 return move;
293 }
294
295 template<typename Derived>
macros(const impl::MacroProps & macros) const296 Derived NumberFormatterSettings<Derived>::macros(const impl::MacroProps& macros) const& {
297 Derived copy(*this);
298 copy.fMacros = macros;
299 return copy;
300 }
301
302 template<typename Derived>
macros(const impl::MacroProps & macros)303 Derived NumberFormatterSettings<Derived>::macros(const impl::MacroProps& macros)&& {
304 Derived move(std::move(*this));
305 move.fMacros = macros;
306 return move;
307 }
308
309 template<typename Derived>
macros(impl::MacroProps && macros) const310 Derived NumberFormatterSettings<Derived>::macros(impl::MacroProps&& macros) const& {
311 Derived copy(*this);
312 copy.fMacros = std::move(macros);
313 return copy;
314 }
315
316 template<typename Derived>
macros(impl::MacroProps && macros)317 Derived NumberFormatterSettings<Derived>::macros(impl::MacroProps&& macros)&& {
318 Derived move(std::move(*this));
319 move.fMacros = std::move(macros);
320 return move;
321 }
322
323 template<typename Derived>
toSkeleton(UErrorCode & status) const324 UnicodeString NumberFormatterSettings<Derived>::toSkeleton(UErrorCode& status) const {
325 if (fMacros.copyErrorTo(status)) {
326 return ICU_Utility::makeBogusString();
327 }
328 return skeleton::generate(fMacros, status);
329 }
330
331 // Declare all classes that implement NumberFormatterSettings
332 // See https://stackoverflow.com/a/495056/1407170
333 template
334 class icu::number::NumberFormatterSettings<icu::number::UnlocalizedNumberFormatter>;
335 template
336 class icu::number::NumberFormatterSettings<icu::number::LocalizedNumberFormatter>;
337
338
with()339 UnlocalizedNumberFormatter NumberFormatter::with() {
340 UnlocalizedNumberFormatter result;
341 return result;
342 }
343
withLocale(const Locale & locale)344 LocalizedNumberFormatter NumberFormatter::withLocale(const Locale& locale) {
345 return with().locale(locale);
346 }
347
348 UnlocalizedNumberFormatter
forSkeleton(const UnicodeString & skeleton,UErrorCode & status)349 NumberFormatter::forSkeleton(const UnicodeString& skeleton, UErrorCode& status) {
350 return skeleton::create(skeleton, status);
351 }
352
353
354 template<typename T> using NFS = NumberFormatterSettings<T>;
355 using LNF = LocalizedNumberFormatter;
356 using UNF = UnlocalizedNumberFormatter;
357
UnlocalizedNumberFormatter(const UNF & other)358 UnlocalizedNumberFormatter::UnlocalizedNumberFormatter(const UNF& other)
359 : UNF(static_cast<const NFS<UNF>&>(other)) {}
360
UnlocalizedNumberFormatter(const NFS<UNF> & other)361 UnlocalizedNumberFormatter::UnlocalizedNumberFormatter(const NFS<UNF>& other)
362 : NFS<UNF>(other) {
363 // No additional fields to assign
364 }
365
366 // Make default copy constructor call the NumberFormatterSettings copy constructor.
UnlocalizedNumberFormatter(UNF && src)367 UnlocalizedNumberFormatter::UnlocalizedNumberFormatter(UNF&& src) U_NOEXCEPT
368 : UNF(static_cast<NFS<UNF>&&>(src)) {}
369
UnlocalizedNumberFormatter(NFS<UNF> && src)370 UnlocalizedNumberFormatter::UnlocalizedNumberFormatter(NFS<UNF>&& src) U_NOEXCEPT
371 : NFS<UNF>(std::move(src)) {
372 // No additional fields to assign
373 }
374
operator =(const UNF & other)375 UnlocalizedNumberFormatter& UnlocalizedNumberFormatter::operator=(const UNF& other) {
376 NFS<UNF>::operator=(static_cast<const NFS<UNF>&>(other));
377 // No additional fields to assign
378 return *this;
379 }
380
operator =(UNF && src)381 UnlocalizedNumberFormatter& UnlocalizedNumberFormatter::operator=(UNF&& src) U_NOEXCEPT {
382 NFS<UNF>::operator=(static_cast<NFS<UNF>&&>(src));
383 // No additional fields to assign
384 return *this;
385 }
386
387 // Make default copy constructor call the NumberFormatterSettings copy constructor.
LocalizedNumberFormatter(const LNF & other)388 LocalizedNumberFormatter::LocalizedNumberFormatter(const LNF& other)
389 : LNF(static_cast<const NFS<LNF>&>(other)) {}
390
LocalizedNumberFormatter(const NFS<LNF> & other)391 LocalizedNumberFormatter::LocalizedNumberFormatter(const NFS<LNF>& other)
392 : NFS<LNF>(other) {
393 // No additional fields to assign (let call count and compiled formatter reset to defaults)
394 }
395
LocalizedNumberFormatter(LocalizedNumberFormatter && src)396 LocalizedNumberFormatter::LocalizedNumberFormatter(LocalizedNumberFormatter&& src) U_NOEXCEPT
397 : LNF(static_cast<NFS<LNF>&&>(src)) {}
398
LocalizedNumberFormatter(NFS<LNF> && src)399 LocalizedNumberFormatter::LocalizedNumberFormatter(NFS<LNF>&& src) U_NOEXCEPT
400 : NFS<LNF>(std::move(src)) {
401 // For the move operators, copy over the compiled formatter.
402 // Note: if the formatter is not compiled, call count information is lost.
403 if (static_cast<LNF&&>(src).fCompiled != nullptr) {
404 lnfMoveHelper(static_cast<LNF&&>(src));
405 }
406 }
407
operator =(const LNF & other)408 LocalizedNumberFormatter& LocalizedNumberFormatter::operator=(const LNF& other) {
409 NFS<LNF>::operator=(static_cast<const NFS<LNF>&>(other));
410 // Reset to default values.
411 clear();
412 return *this;
413 }
414
operator =(LNF && src)415 LocalizedNumberFormatter& LocalizedNumberFormatter::operator=(LNF&& src) U_NOEXCEPT {
416 NFS<LNF>::operator=(static_cast<NFS<LNF>&&>(src));
417 // For the move operators, copy over the compiled formatter.
418 // Note: if the formatter is not compiled, call count information is lost.
419 if (static_cast<LNF&&>(src).fCompiled != nullptr) {
420 // Formatter is compiled
421 lnfMoveHelper(static_cast<LNF&&>(src));
422 } else {
423 clear();
424 }
425 return *this;
426 }
427
clear()428 void LocalizedNumberFormatter::clear() {
429 // Reset to default values.
430 auto* callCount = reinterpret_cast<u_atomic_int32_t*>(fUnsafeCallCount);
431 umtx_storeRelease(*callCount, 0);
432 delete fCompiled;
433 fCompiled = nullptr;
434 }
435
lnfMoveHelper(LNF && src)436 void LocalizedNumberFormatter::lnfMoveHelper(LNF&& src) {
437 // Copy over the compiled formatter and set call count to INT32_MIN as in computeCompiled().
438 // Don't copy the call count directly because doing so requires a loadAcquire/storeRelease.
439 // The bits themselves appear to be platform-dependent, so copying them might not be safe.
440 auto* callCount = reinterpret_cast<u_atomic_int32_t*>(fUnsafeCallCount);
441 umtx_storeRelease(*callCount, INT32_MIN);
442 delete fCompiled;
443 fCompiled = src.fCompiled;
444 // Reset the source object to leave it in a safe state.
445 auto* srcCallCount = reinterpret_cast<u_atomic_int32_t*>(src.fUnsafeCallCount);
446 umtx_storeRelease(*srcCallCount, 0);
447 src.fCompiled = nullptr;
448 }
449
450
~LocalizedNumberFormatter()451 LocalizedNumberFormatter::~LocalizedNumberFormatter() {
452 delete fCompiled;
453 }
454
LocalizedNumberFormatter(const MacroProps & macros,const Locale & locale)455 LocalizedNumberFormatter::LocalizedNumberFormatter(const MacroProps& macros, const Locale& locale) {
456 fMacros = macros;
457 fMacros.locale = locale;
458 }
459
LocalizedNumberFormatter(MacroProps && macros,const Locale & locale)460 LocalizedNumberFormatter::LocalizedNumberFormatter(MacroProps&& macros, const Locale& locale) {
461 fMacros = std::move(macros);
462 fMacros.locale = locale;
463 }
464
locale(const Locale & locale) const465 LocalizedNumberFormatter UnlocalizedNumberFormatter::locale(const Locale& locale) const& {
466 return LocalizedNumberFormatter(fMacros, locale);
467 }
468
locale(const Locale & locale)469 LocalizedNumberFormatter UnlocalizedNumberFormatter::locale(const Locale& locale)&& {
470 return LocalizedNumberFormatter(std::move(fMacros), locale);
471 }
472
SymbolsWrapper(const SymbolsWrapper & other)473 SymbolsWrapper::SymbolsWrapper(const SymbolsWrapper& other) {
474 doCopyFrom(other);
475 }
476
SymbolsWrapper(SymbolsWrapper && src)477 SymbolsWrapper::SymbolsWrapper(SymbolsWrapper&& src) U_NOEXCEPT {
478 doMoveFrom(std::move(src));
479 }
480
operator =(const SymbolsWrapper & other)481 SymbolsWrapper& SymbolsWrapper::operator=(const SymbolsWrapper& other) {
482 if (this == &other) {
483 return *this;
484 }
485 doCleanup();
486 doCopyFrom(other);
487 return *this;
488 }
489
operator =(SymbolsWrapper && src)490 SymbolsWrapper& SymbolsWrapper::operator=(SymbolsWrapper&& src) U_NOEXCEPT {
491 if (this == &src) {
492 return *this;
493 }
494 doCleanup();
495 doMoveFrom(std::move(src));
496 return *this;
497 }
498
~SymbolsWrapper()499 SymbolsWrapper::~SymbolsWrapper() {
500 doCleanup();
501 }
502
setTo(const DecimalFormatSymbols & dfs)503 void SymbolsWrapper::setTo(const DecimalFormatSymbols& dfs) {
504 doCleanup();
505 fType = SYMPTR_DFS;
506 fPtr.dfs = new DecimalFormatSymbols(dfs);
507 }
508
setTo(const NumberingSystem * ns)509 void SymbolsWrapper::setTo(const NumberingSystem* ns) {
510 doCleanup();
511 fType = SYMPTR_NS;
512 fPtr.ns = ns;
513 }
514
doCopyFrom(const SymbolsWrapper & other)515 void SymbolsWrapper::doCopyFrom(const SymbolsWrapper& other) {
516 fType = other.fType;
517 switch (fType) {
518 case SYMPTR_NONE:
519 // No action necessary
520 break;
521 case SYMPTR_DFS:
522 // Memory allocation failures are exposed in copyErrorTo()
523 if (other.fPtr.dfs != nullptr) {
524 fPtr.dfs = new DecimalFormatSymbols(*other.fPtr.dfs);
525 } else {
526 fPtr.dfs = nullptr;
527 }
528 break;
529 case SYMPTR_NS:
530 // Memory allocation failures are exposed in copyErrorTo()
531 if (other.fPtr.ns != nullptr) {
532 fPtr.ns = new NumberingSystem(*other.fPtr.ns);
533 } else {
534 fPtr.ns = nullptr;
535 }
536 break;
537 }
538 }
539
doMoveFrom(SymbolsWrapper && src)540 void SymbolsWrapper::doMoveFrom(SymbolsWrapper&& src) {
541 fType = src.fType;
542 switch (fType) {
543 case SYMPTR_NONE:
544 // No action necessary
545 break;
546 case SYMPTR_DFS:
547 fPtr.dfs = src.fPtr.dfs;
548 src.fPtr.dfs = nullptr;
549 break;
550 case SYMPTR_NS:
551 fPtr.ns = src.fPtr.ns;
552 src.fPtr.ns = nullptr;
553 break;
554 }
555 }
556
doCleanup()557 void SymbolsWrapper::doCleanup() {
558 switch (fType) {
559 case SYMPTR_NONE:
560 // No action necessary
561 break;
562 case SYMPTR_DFS:
563 delete fPtr.dfs;
564 break;
565 case SYMPTR_NS:
566 delete fPtr.ns;
567 break;
568 }
569 }
570
isDecimalFormatSymbols() const571 bool SymbolsWrapper::isDecimalFormatSymbols() const {
572 return fType == SYMPTR_DFS;
573 }
574
isNumberingSystem() const575 bool SymbolsWrapper::isNumberingSystem() const {
576 return fType == SYMPTR_NS;
577 }
578
getDecimalFormatSymbols() const579 const DecimalFormatSymbols* SymbolsWrapper::getDecimalFormatSymbols() const {
580 U_ASSERT(fType == SYMPTR_DFS);
581 return fPtr.dfs;
582 }
583
getNumberingSystem() const584 const NumberingSystem* SymbolsWrapper::getNumberingSystem() const {
585 U_ASSERT(fType == SYMPTR_NS);
586 return fPtr.ns;
587 }
588
589
formatInt(int64_t value,UErrorCode & status) const590 FormattedNumber LocalizedNumberFormatter::formatInt(int64_t value, UErrorCode& status) const {
591 if (U_FAILURE(status)) { return FormattedNumber(U_ILLEGAL_ARGUMENT_ERROR); }
592 auto results = new UFormattedNumberData();
593 if (results == nullptr) {
594 status = U_MEMORY_ALLOCATION_ERROR;
595 return FormattedNumber(status);
596 }
597 results->quantity.setToLong(value);
598 formatImpl(results, status);
599
600 // Do not save the results object if we encountered a failure.
601 if (U_SUCCESS(status)) {
602 return FormattedNumber(results);
603 } else {
604 delete results;
605 return FormattedNumber(status);
606 }
607 }
608
formatDouble(double value,UErrorCode & status) const609 FormattedNumber LocalizedNumberFormatter::formatDouble(double value, UErrorCode& status) const {
610 if (U_FAILURE(status)) { return FormattedNumber(U_ILLEGAL_ARGUMENT_ERROR); }
611 auto results = new UFormattedNumberData();
612 if (results == nullptr) {
613 status = U_MEMORY_ALLOCATION_ERROR;
614 return FormattedNumber(status);
615 }
616 results->quantity.setToDouble(value);
617 formatImpl(results, status);
618
619 // Do not save the results object if we encountered a failure.
620 if (U_SUCCESS(status)) {
621 return FormattedNumber(results);
622 } else {
623 delete results;
624 return FormattedNumber(status);
625 }
626 }
627
formatDecimal(StringPiece value,UErrorCode & status) const628 FormattedNumber LocalizedNumberFormatter::formatDecimal(StringPiece value, UErrorCode& status) const {
629 if (U_FAILURE(status)) { return FormattedNumber(U_ILLEGAL_ARGUMENT_ERROR); }
630 auto results = new UFormattedNumberData();
631 if (results == nullptr) {
632 status = U_MEMORY_ALLOCATION_ERROR;
633 return FormattedNumber(status);
634 }
635 results->quantity.setToDecNumber(value, status);
636 formatImpl(results, status);
637
638 // Do not save the results object if we encountered a failure.
639 if (U_SUCCESS(status)) {
640 return FormattedNumber(results);
641 } else {
642 delete results;
643 return FormattedNumber(status);
644 }
645 }
646
647 FormattedNumber
formatDecimalQuantity(const DecimalQuantity & dq,UErrorCode & status) const648 LocalizedNumberFormatter::formatDecimalQuantity(const DecimalQuantity& dq, UErrorCode& status) const {
649 if (U_FAILURE(status)) { return FormattedNumber(U_ILLEGAL_ARGUMENT_ERROR); }
650 auto results = new UFormattedNumberData();
651 if (results == nullptr) {
652 status = U_MEMORY_ALLOCATION_ERROR;
653 return FormattedNumber(status);
654 }
655 results->quantity = dq;
656 formatImpl(results, status);
657
658 // Do not save the results object if we encountered a failure.
659 if (U_SUCCESS(status)) {
660 return FormattedNumber(results);
661 } else {
662 delete results;
663 return FormattedNumber(status);
664 }
665 }
666
formatImpl(impl::UFormattedNumberData * results,UErrorCode & status) const667 void LocalizedNumberFormatter::formatImpl(impl::UFormattedNumberData* results, UErrorCode& status) const {
668 if (computeCompiled(status)) {
669 fCompiled->format(results->quantity, results->string, status);
670 } else {
671 NumberFormatterImpl::formatStatic(fMacros, results->quantity, results->string, status);
672 }
673 }
674
getAffixImpl(bool isPrefix,bool isNegative,UnicodeString & result,UErrorCode & status) const675 void LocalizedNumberFormatter::getAffixImpl(bool isPrefix, bool isNegative, UnicodeString& result,
676 UErrorCode& status) const {
677 NumberStringBuilder string;
678 auto signum = static_cast<int8_t>(isNegative ? -1 : 1);
679 // Always return affixes for plural form OTHER.
680 static const StandardPlural::Form plural = StandardPlural::OTHER;
681 int32_t prefixLength;
682 if (computeCompiled(status)) {
683 prefixLength = fCompiled->getPrefixSuffix(signum, plural, string, status);
684 } else {
685 prefixLength = NumberFormatterImpl::getPrefixSuffixStatic(fMacros, signum, plural, string, status);
686 }
687 result.remove();
688 if (isPrefix) {
689 result.append(string.toTempUnicodeString().tempSubStringBetween(0, prefixLength));
690 } else {
691 result.append(string.toTempUnicodeString().tempSubStringBetween(prefixLength, string.length()));
692 }
693 }
694
computeCompiled(UErrorCode & status) const695 bool LocalizedNumberFormatter::computeCompiled(UErrorCode& status) const {
696 // fUnsafeCallCount contains memory to be interpreted as an atomic int, most commonly
697 // std::atomic<int32_t>. Since the type of atomic int is platform-dependent, we cast the
698 // bytes in fUnsafeCallCount to u_atomic_int32_t, a typedef for the platform-dependent
699 // atomic int type defined in umutex.h.
700 static_assert(
701 sizeof(u_atomic_int32_t) <= sizeof(fUnsafeCallCount),
702 "Atomic integer size on this platform exceeds the size allocated by fUnsafeCallCount");
703 auto* callCount = reinterpret_cast<u_atomic_int32_t*>(
704 const_cast<LocalizedNumberFormatter*>(this)->fUnsafeCallCount);
705
706 // A positive value in the atomic int indicates that the data structure is not yet ready;
707 // a negative value indicates that it is ready. If, after the increment, the atomic int
708 // is exactly threshold, then it is the current thread's job to build the data structure.
709 // Note: We set the callCount to INT32_MIN so that if another thread proceeds to increment
710 // the atomic int, the value remains below zero.
711 int32_t currentCount = umtx_loadAcquire(*callCount);
712 if (0 <= currentCount && currentCount <= fMacros.threshold && fMacros.threshold > 0) {
713 currentCount = umtx_atomic_inc(callCount);
714 }
715
716 if (currentCount == fMacros.threshold && fMacros.threshold > 0) {
717 // Build the data structure and then use it (slow to fast path).
718 const NumberFormatterImpl* compiled = new NumberFormatterImpl(fMacros, status);
719 if (compiled == nullptr) {
720 status = U_MEMORY_ALLOCATION_ERROR;
721 return false;
722 }
723 U_ASSERT(fCompiled == nullptr);
724 const_cast<LocalizedNumberFormatter*>(this)->fCompiled = compiled;
725 umtx_storeRelease(*callCount, INT32_MIN);
726 return true;
727 } else if (currentCount < 0) {
728 // The data structure is already built; use it (fast path).
729 U_ASSERT(fCompiled != nullptr);
730 return true;
731 } else {
732 // Format the number without building the data structure (slow path).
733 return false;
734 }
735 }
736
getCompiled() const737 const impl::NumberFormatterImpl* LocalizedNumberFormatter::getCompiled() const {
738 return fCompiled;
739 }
740
getCallCount() const741 int32_t LocalizedNumberFormatter::getCallCount() const {
742 auto* callCount = reinterpret_cast<u_atomic_int32_t*>(
743 const_cast<LocalizedNumberFormatter*>(this)->fUnsafeCallCount);
744 return umtx_loadAcquire(*callCount);
745 }
746
toFormat(UErrorCode & status) const747 Format* LocalizedNumberFormatter::toFormat(UErrorCode& status) const {
748 LocalPointer<LocalizedNumberFormatterAsFormat> retval(
749 new LocalizedNumberFormatterAsFormat(*this, fMacros.locale), status);
750 return retval.orphan();
751 }
752
753
FormattedNumber(FormattedNumber && src)754 FormattedNumber::FormattedNumber(FormattedNumber&& src) U_NOEXCEPT
755 : fResults(src.fResults), fErrorCode(src.fErrorCode) {
756 // Disown src.fResults to prevent double-deletion
757 src.fResults = nullptr;
758 src.fErrorCode = U_INVALID_STATE_ERROR;
759 }
760
operator =(FormattedNumber && src)761 FormattedNumber& FormattedNumber::operator=(FormattedNumber&& src) U_NOEXCEPT {
762 delete fResults;
763 fResults = src.fResults;
764 fErrorCode = src.fErrorCode;
765 // Disown src.fResults to prevent double-deletion
766 src.fResults = nullptr;
767 src.fErrorCode = U_INVALID_STATE_ERROR;
768 return *this;
769 }
770
toString() const771 UnicodeString FormattedNumber::toString() const {
772 UErrorCode localStatus = U_ZERO_ERROR;
773 return toString(localStatus);
774 }
775
toString(UErrorCode & status) const776 UnicodeString FormattedNumber::toString(UErrorCode& status) const {
777 if (U_FAILURE(status)) {
778 return ICU_Utility::makeBogusString();
779 }
780 if (fResults == nullptr) {
781 status = fErrorCode;
782 return ICU_Utility::makeBogusString();
783 }
784 return fResults->string.toUnicodeString();
785 }
786
appendTo(Appendable & appendable)787 Appendable& FormattedNumber::appendTo(Appendable& appendable) {
788 UErrorCode localStatus = U_ZERO_ERROR;
789 return appendTo(appendable, localStatus);
790 }
791
appendTo(Appendable & appendable,UErrorCode & status) const792 Appendable& FormattedNumber::appendTo(Appendable& appendable, UErrorCode& status) const {
793 if (U_FAILURE(status)) {
794 return appendable;
795 }
796 if (fResults == nullptr) {
797 status = fErrorCode;
798 return appendable;
799 }
800 appendable.appendString(fResults->string.chars(), fResults->string.length());
801 return appendable;
802 }
803
populateFieldPosition(FieldPosition & fieldPosition,UErrorCode & status)804 void FormattedNumber::populateFieldPosition(FieldPosition& fieldPosition, UErrorCode& status) {
805 if (U_FAILURE(status)) {
806 return;
807 }
808 if (fResults == nullptr) {
809 status = fErrorCode;
810 return;
811 }
812 // in case any users were depending on the old behavior:
813 fieldPosition.setBeginIndex(0);
814 fieldPosition.setEndIndex(0);
815 fResults->string.nextFieldPosition(fieldPosition, status);
816 }
817
nextFieldPosition(FieldPosition & fieldPosition,UErrorCode & status) const818 UBool FormattedNumber::nextFieldPosition(FieldPosition& fieldPosition, UErrorCode& status) const {
819 if (U_FAILURE(status)) {
820 return FALSE;
821 }
822 if (fResults == nullptr) {
823 status = fErrorCode;
824 return FALSE;
825 }
826 // NOTE: MSVC sometimes complains when implicitly converting between bool and UBool
827 return fResults->string.nextFieldPosition(fieldPosition, status) ? TRUE : FALSE;
828 }
829
populateFieldPositionIterator(FieldPositionIterator & iterator,UErrorCode & status)830 void FormattedNumber::populateFieldPositionIterator(FieldPositionIterator& iterator, UErrorCode& status) {
831 getAllFieldPositions(iterator, status);
832 }
833
getAllFieldPositions(FieldPositionIterator & iterator,UErrorCode & status) const834 void FormattedNumber::getAllFieldPositions(FieldPositionIterator& iterator, UErrorCode& status) const {
835 FieldPositionIteratorHandler fpih(&iterator, status);
836 getAllFieldPositionsImpl(fpih, status);
837 }
838
getAllFieldPositionsImpl(FieldPositionIteratorHandler & fpih,UErrorCode & status) const839 void FormattedNumber::getAllFieldPositionsImpl(FieldPositionIteratorHandler& fpih,
840 UErrorCode& status) const {
841 if (U_FAILURE(status)) {
842 return;
843 }
844 if (fResults == nullptr) {
845 status = fErrorCode;
846 return;
847 }
848 fResults->string.getAllFieldPositions(fpih, status);
849 }
850
getDecimalQuantity(DecimalQuantity & output,UErrorCode & status) const851 void FormattedNumber::getDecimalQuantity(DecimalQuantity& output, UErrorCode& status) const {
852 if (U_FAILURE(status)) {
853 return;
854 }
855 if (fResults == nullptr) {
856 status = fErrorCode;
857 return;
858 }
859 output = fResults->quantity;
860 }
861
~FormattedNumber()862 FormattedNumber::~FormattedNumber() {
863 delete fResults;
864 }
865
866 #endif /* #if !UCONFIG_NO_FORMATTING */
867