summaryrefslogtreecommitdiff
path: root/deps/icu-small/source/i18n/number_fluent.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'deps/icu-small/source/i18n/number_fluent.cpp')
-rw-r--r--deps/icu-small/source/i18n/number_fluent.cpp625
1 files changed, 543 insertions, 82 deletions
diff --git a/deps/icu-small/source/i18n/number_fluent.cpp b/deps/icu-small/source/i18n/number_fluent.cpp
index 27113106c5..687adb6b5b 100644
--- a/deps/icu-small/source/i18n/number_fluent.cpp
+++ b/deps/icu-small/source/i18n/number_fluent.cpp
@@ -3,20 +3,26 @@
#include "unicode/utypes.h"
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
#include "uassert.h"
#include "unicode/numberformatter.h"
#include "number_decimalquantity.h"
#include "number_formatimpl.h"
#include "umutex.h"
+#include "number_asformat.h"
+#include "number_skeletons.h"
+#include "number_utils.h"
+#include "number_utypes.h"
+#include "util.h"
+#include "fphdlimp.h"
using namespace icu;
using namespace icu::number;
using namespace icu::number::impl;
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::notation(const Notation &notation) const {
+Derived NumberFormatterSettings<Derived>::notation(const Notation& notation) const& {
Derived copy(*this);
// NOTE: Slicing is OK.
copy.fMacros.notation = notation;
@@ -24,7 +30,15 @@ Derived NumberFormatterSettings<Derived>::notation(const Notation &notation) con
}
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::unit(const icu::MeasureUnit &unit) const {
+Derived NumberFormatterSettings<Derived>::notation(const Notation& notation)&& {
+ Derived move(std::move(*this));
+ // NOTE: Slicing is OK.
+ move.fMacros.notation = notation;
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::unit(const icu::MeasureUnit& unit) const& {
Derived copy(*this);
// NOTE: Slicing occurs here. However, CurrencyUnit can be restored from MeasureUnit.
// TimeUnit may be affected, but TimeUnit is not as relevant to number formatting.
@@ -33,21 +47,41 @@ Derived NumberFormatterSettings<Derived>::unit(const icu::MeasureUnit &unit) con
}
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::adoptUnit(icu::MeasureUnit *unit) const {
+Derived NumberFormatterSettings<Derived>::unit(const icu::MeasureUnit& unit)&& {
+ Derived move(std::move(*this));
+ // See comments above about slicing.
+ move.fMacros.unit = unit;
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::adoptUnit(icu::MeasureUnit* unit) const& {
Derived copy(*this);
- // Just copy the unit into the MacroProps by value, and delete it since we have ownership.
+ // Just move the unit into the MacroProps by value, and delete it since we have ownership.
// NOTE: Slicing occurs here. However, CurrencyUnit can be restored from MeasureUnit.
// TimeUnit may be affected, but TimeUnit is not as relevant to number formatting.
if (unit != nullptr) {
- // TODO: On nullptr, reset to default value?
- copy.fMacros.unit = *unit;
+ // TODO: On nullptr, reset to default value?
+ copy.fMacros.unit = std::move(*unit);
delete unit;
}
return copy;
}
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::perUnit(const icu::MeasureUnit &perUnit) const {
+Derived NumberFormatterSettings<Derived>::adoptUnit(icu::MeasureUnit* unit)&& {
+ Derived move(std::move(*this));
+ // See comments above about slicing and ownership.
+ if (unit != nullptr) {
+ // TODO: On nullptr, reset to default value?
+ move.fMacros.unit = std::move(*unit);
+ delete unit;
+ }
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::perUnit(const icu::MeasureUnit& perUnit) const& {
Derived copy(*this);
// See comments above about slicing.
copy.fMacros.perUnit = perUnit;
@@ -55,27 +89,69 @@ Derived NumberFormatterSettings<Derived>::perUnit(const icu::MeasureUnit &perUni
}
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::adoptPerUnit(icu::MeasureUnit *perUnit) const {
+Derived NumberFormatterSettings<Derived>::perUnit(const icu::MeasureUnit& perUnit)&& {
+ Derived move(std::move(*this));
+ // See comments above about slicing.
+ move.fMacros.perUnit = perUnit;
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::adoptPerUnit(icu::MeasureUnit* perUnit) const& {
Derived copy(*this);
// See comments above about slicing and ownership.
if (perUnit != nullptr) {
- // TODO: On nullptr, reset to default value?
- copy.fMacros.perUnit = *perUnit;
+ // TODO: On nullptr, reset to default value?
+ copy.fMacros.perUnit = std::move(*perUnit);
delete perUnit;
}
return copy;
}
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::rounding(const Rounder &rounder) const {
+Derived NumberFormatterSettings<Derived>::adoptPerUnit(icu::MeasureUnit* perUnit)&& {
+ Derived move(std::move(*this));
+ // See comments above about slicing and ownership.
+ if (perUnit != nullptr) {
+ // TODO: On nullptr, reset to default value?
+ move.fMacros.perUnit = std::move(*perUnit);
+ delete perUnit;
+ }
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::precision(const Precision& precision) const& {
Derived copy(*this);
// NOTE: Slicing is OK.
- copy.fMacros.rounder = rounder;
+ copy.fMacros.precision = precision;
return copy;
}
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::grouping(const UGroupingStrategy &strategy) const {
+Derived NumberFormatterSettings<Derived>::precision(const Precision& precision)&& {
+ Derived move(std::move(*this));
+ // NOTE: Slicing is OK.
+ move.fMacros.precision = precision;
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::roundingMode(UNumberFormatRoundingMode roundingMode) const& {
+ Derived copy(*this);
+ copy.fMacros.roundingMode = roundingMode;
+ return copy;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::roundingMode(UNumberFormatRoundingMode roundingMode)&& {
+ Derived move(std::move(*this));
+ move.fMacros.roundingMode = roundingMode;
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::grouping(UGroupingStrategy strategy) const& {
Derived copy(*this);
// NOTE: This is slightly different than how the setting is stored in Java
// because we want to put it on the stack.
@@ -84,61 +160,174 @@ Derived NumberFormatterSettings<Derived>::grouping(const UGroupingStrategy &stra
}
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::integerWidth(const IntegerWidth &style) const {
+Derived NumberFormatterSettings<Derived>::grouping(UGroupingStrategy strategy)&& {
+ Derived move(std::move(*this));
+ move.fMacros.grouper = Grouper::forStrategy(strategy);
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::integerWidth(const IntegerWidth& style) const& {
Derived copy(*this);
copy.fMacros.integerWidth = style;
return copy;
}
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::symbols(const DecimalFormatSymbols &symbols) const {
+Derived NumberFormatterSettings<Derived>::integerWidth(const IntegerWidth& style)&& {
+ Derived move(std::move(*this));
+ move.fMacros.integerWidth = style;
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::symbols(const DecimalFormatSymbols& symbols) const& {
Derived copy(*this);
copy.fMacros.symbols.setTo(symbols);
return copy;
}
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::adoptSymbols(NumberingSystem *ns) const {
+Derived NumberFormatterSettings<Derived>::symbols(const DecimalFormatSymbols& symbols)&& {
+ Derived move(std::move(*this));
+ move.fMacros.symbols.setTo(symbols);
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::adoptSymbols(NumberingSystem* ns) const& {
Derived copy(*this);
copy.fMacros.symbols.setTo(ns);
return copy;
}
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::unitWidth(const UNumberUnitWidth &width) const {
+Derived NumberFormatterSettings<Derived>::adoptSymbols(NumberingSystem* ns)&& {
+ Derived move(std::move(*this));
+ move.fMacros.symbols.setTo(ns);
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::unitWidth(UNumberUnitWidth width) const& {
Derived copy(*this);
copy.fMacros.unitWidth = width;
return copy;
}
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::sign(const UNumberSignDisplay &style) const {
+Derived NumberFormatterSettings<Derived>::unitWidth(UNumberUnitWidth width)&& {
+ Derived move(std::move(*this));
+ move.fMacros.unitWidth = width;
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::sign(UNumberSignDisplay style) const& {
Derived copy(*this);
copy.fMacros.sign = style;
return copy;
}
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::decimal(const UNumberDecimalSeparatorDisplay &style) const {
+Derived NumberFormatterSettings<Derived>::sign(UNumberSignDisplay style)&& {
+ Derived move(std::move(*this));
+ move.fMacros.sign = style;
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::decimal(UNumberDecimalSeparatorDisplay style) const& {
Derived copy(*this);
copy.fMacros.decimal = style;
return copy;
}
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::padding(const Padder &padder) const {
+Derived NumberFormatterSettings<Derived>::decimal(UNumberDecimalSeparatorDisplay style)&& {
+ Derived move(std::move(*this));
+ move.fMacros.decimal = style;
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::scale(const Scale& scale) const& {
+ Derived copy(*this);
+ copy.fMacros.scale = scale;
+ return copy;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::scale(const Scale& scale)&& {
+ Derived move(std::move(*this));
+ move.fMacros.scale = scale;
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::padding(const Padder& padder) const& {
Derived copy(*this);
copy.fMacros.padder = padder;
return copy;
}
template<typename Derived>
-Derived NumberFormatterSettings<Derived>::threshold(int32_t threshold) const {
+Derived NumberFormatterSettings<Derived>::padding(const Padder& padder)&& {
+ Derived move(std::move(*this));
+ move.fMacros.padder = padder;
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::threshold(int32_t threshold) const& {
Derived copy(*this);
copy.fMacros.threshold = threshold;
return copy;
}
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::threshold(int32_t threshold)&& {
+ Derived move(std::move(*this));
+ move.fMacros.threshold = threshold;
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::macros(const impl::MacroProps& macros) const& {
+ Derived copy(*this);
+ copy.fMacros = macros;
+ return copy;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::macros(const impl::MacroProps& macros)&& {
+ Derived move(std::move(*this));
+ move.fMacros = macros;
+ return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::macros(impl::MacroProps&& macros) const& {
+ Derived copy(*this);
+ copy.fMacros = std::move(macros);
+ return copy;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::macros(impl::MacroProps&& macros)&& {
+ Derived move(std::move(*this));
+ move.fMacros = std::move(macros);
+ return move;
+}
+
+template<typename Derived>
+UnicodeString NumberFormatterSettings<Derived>::toSkeleton(UErrorCode& status) const {
+ if (fMacros.copyErrorTo(status)) {
+ return ICU_Utility::makeBogusString();
+ }
+ return skeleton::generate(fMacros, status);
+}
+
// Declare all classes that implement NumberFormatterSettings
// See https://stackoverflow.com/a/495056/1407170
template
@@ -152,38 +341,135 @@ UnlocalizedNumberFormatter NumberFormatter::with() {
return result;
}
-LocalizedNumberFormatter NumberFormatter::withLocale(const Locale &locale) {
+LocalizedNumberFormatter NumberFormatter::withLocale(const Locale& locale) {
return with().locale(locale);
}
-// Make the child class constructor that takes the parent class call the parent class's copy constructor
-UnlocalizedNumberFormatter::UnlocalizedNumberFormatter(
- const NumberFormatterSettings <UnlocalizedNumberFormatter> &other)
- : NumberFormatterSettings<UnlocalizedNumberFormatter>(other) {
+UnlocalizedNumberFormatter
+NumberFormatter::forSkeleton(const UnicodeString& skeleton, UErrorCode& status) {
+ return skeleton::create(skeleton, status);
+}
+
+
+template<typename T> using NFS = NumberFormatterSettings<T>;
+using LNF = LocalizedNumberFormatter;
+using UNF = UnlocalizedNumberFormatter;
+
+UnlocalizedNumberFormatter::UnlocalizedNumberFormatter(const UNF& other)
+ : UNF(static_cast<const NFS<UNF>&>(other)) {}
+
+UnlocalizedNumberFormatter::UnlocalizedNumberFormatter(const NFS<UNF>& other)
+ : NFS<UNF>(other) {
+ // No additional fields to assign
+}
+
+UnlocalizedNumberFormatter::UnlocalizedNumberFormatter(UNF&& src) U_NOEXCEPT
+ : UNF(static_cast<NFS<UNF>&&>(src)) {}
+
+UnlocalizedNumberFormatter::UnlocalizedNumberFormatter(NFS<UNF>&& src) U_NOEXCEPT
+ : NFS<UNF>(std::move(src)) {
+ // No additional fields to assign
+}
+
+UnlocalizedNumberFormatter& UnlocalizedNumberFormatter::operator=(const UNF& other) {
+ NFS<UNF>::operator=(static_cast<const NFS<UNF>&>(other));
+ // No additional fields to assign
+ return *this;
+}
+
+UnlocalizedNumberFormatter& UnlocalizedNumberFormatter::operator=(UNF&& src) U_NOEXCEPT {
+ NFS<UNF>::operator=(static_cast<NFS<UNF>&&>(src));
+ // No additional fields to assign
+ return *this;
+}
+
+LocalizedNumberFormatter::LocalizedNumberFormatter(const LNF& other)
+ : LNF(static_cast<const NFS<LNF>&>(other)) {}
+
+LocalizedNumberFormatter::LocalizedNumberFormatter(const NFS<LNF>& other)
+ : NFS<LNF>(other) {
+ // No additional fields to assign (let call count and compiled formatter reset to defaults)
+}
+
+LocalizedNumberFormatter::LocalizedNumberFormatter(LocalizedNumberFormatter&& src) U_NOEXCEPT
+ : LNF(static_cast<NFS<LNF>&&>(src)) {}
+
+LocalizedNumberFormatter::LocalizedNumberFormatter(NFS<LNF>&& src) U_NOEXCEPT
+ : NFS<LNF>(std::move(src)) {
+ // For the move operators, copy over the compiled formatter.
+ // Note: if the formatter is not compiled, call count information is lost.
+ if (static_cast<LNF&&>(src).fCompiled != nullptr) {
+ lnfMoveHelper(static_cast<LNF&&>(src));
+ }
+}
+
+LocalizedNumberFormatter& LocalizedNumberFormatter::operator=(const LNF& other) {
+ NFS<LNF>::operator=(static_cast<const NFS<LNF>&>(other));
+ // No additional fields to assign (let call count and compiled formatter reset to defaults)
+ return *this;
+}
+
+LocalizedNumberFormatter& LocalizedNumberFormatter::operator=(LNF&& src) U_NOEXCEPT {
+ NFS<LNF>::operator=(static_cast<NFS<LNF>&&>(src));
+ // For the move operators, copy over the compiled formatter.
+ // Note: if the formatter is not compiled, call count information is lost.
+ if (static_cast<LNF&&>(src).fCompiled != nullptr) {
+ // Formatter is compiled
+ lnfMoveHelper(static_cast<LNF&&>(src));
+ } else {
+ // Reset to default values.
+ auto* callCount = reinterpret_cast<u_atomic_int32_t*>(fUnsafeCallCount);
+ umtx_storeRelease(*callCount, 0);
+ fCompiled = nullptr;
+ }
+ return *this;
+}
+
+void LocalizedNumberFormatter::lnfMoveHelper(LNF&& src) {
+ // Copy over the compiled formatter and set call count to INT32_MIN as in computeCompiled().
+ // Don't copy the call count directly because doing so requires a loadAcquire/storeRelease.
+ // The bits themselves appear to be platform-dependent, so copying them might not be safe.
+ auto* callCount = reinterpret_cast<u_atomic_int32_t*>(fUnsafeCallCount);
+ umtx_storeRelease(*callCount, INT32_MIN);
+ fCompiled = src.fCompiled;
+ // Reset the source object to leave it in a safe state.
+ auto* srcCallCount = reinterpret_cast<u_atomic_int32_t*>(src.fUnsafeCallCount);
+ umtx_storeRelease(*srcCallCount, 0);
+ src.fCompiled = nullptr;
}
-// Make the child class constructor that takes the parent class call the parent class's copy constructor
-// For LocalizedNumberFormatter, also copy over the extra fields
-LocalizedNumberFormatter::LocalizedNumberFormatter(
- const NumberFormatterSettings <LocalizedNumberFormatter> &other)
- : NumberFormatterSettings<LocalizedNumberFormatter>(other) {
- // No additional copies required
+
+LocalizedNumberFormatter::~LocalizedNumberFormatter() {
+ delete fCompiled;
}
-LocalizedNumberFormatter::LocalizedNumberFormatter(const MacroProps &macros, const Locale &locale) {
+LocalizedNumberFormatter::LocalizedNumberFormatter(const MacroProps& macros, const Locale& locale) {
fMacros = macros;
fMacros.locale = locale;
}
-LocalizedNumberFormatter UnlocalizedNumberFormatter::locale(const Locale &locale) const {
+LocalizedNumberFormatter::LocalizedNumberFormatter(MacroProps&& macros, const Locale& locale) {
+ fMacros = std::move(macros);
+ fMacros.locale = locale;
+}
+
+LocalizedNumberFormatter UnlocalizedNumberFormatter::locale(const Locale& locale) const& {
return LocalizedNumberFormatter(fMacros, locale);
}
-SymbolsWrapper::SymbolsWrapper(const SymbolsWrapper &other) {
+LocalizedNumberFormatter UnlocalizedNumberFormatter::locale(const Locale& locale)&& {
+ return LocalizedNumberFormatter(std::move(fMacros), locale);
+}
+
+SymbolsWrapper::SymbolsWrapper(const SymbolsWrapper& other) {
doCopyFrom(other);
}
-SymbolsWrapper &SymbolsWrapper::operator=(const SymbolsWrapper &other) {
+SymbolsWrapper::SymbolsWrapper(SymbolsWrapper&& src) U_NOEXCEPT {
+ doMoveFrom(std::move(src));
+}
+
+SymbolsWrapper& SymbolsWrapper::operator=(const SymbolsWrapper& other) {
if (this == &other) {
return *this;
}
@@ -192,23 +478,32 @@ SymbolsWrapper &SymbolsWrapper::operator=(const SymbolsWrapper &other) {
return *this;
}
+SymbolsWrapper& SymbolsWrapper::operator=(SymbolsWrapper&& src) U_NOEXCEPT {
+ if (this == &src) {
+ return *this;
+ }
+ doCleanup();
+ doMoveFrom(std::move(src));
+ return *this;
+}
+
SymbolsWrapper::~SymbolsWrapper() {
doCleanup();
}
-void SymbolsWrapper::setTo(const DecimalFormatSymbols &dfs) {
+void SymbolsWrapper::setTo(const DecimalFormatSymbols& dfs) {
doCleanup();
fType = SYMPTR_DFS;
fPtr.dfs = new DecimalFormatSymbols(dfs);
}
-void SymbolsWrapper::setTo(const NumberingSystem *ns) {
+void SymbolsWrapper::setTo(const NumberingSystem* ns) {
doCleanup();
fType = SYMPTR_NS;
fPtr.ns = ns;
}
-void SymbolsWrapper::doCopyFrom(const SymbolsWrapper &other) {
+void SymbolsWrapper::doCopyFrom(const SymbolsWrapper& other) {
fType = other.fType;
switch (fType) {
case SYMPTR_NONE:
@@ -233,6 +528,23 @@ void SymbolsWrapper::doCopyFrom(const SymbolsWrapper &other) {
}
}
+void SymbolsWrapper::doMoveFrom(SymbolsWrapper&& src) {
+ fType = src.fType;
+ switch (fType) {
+ case SYMPTR_NONE:
+ // No action necessary
+ break;
+ case SYMPTR_DFS:
+ fPtr.dfs = src.fPtr.dfs;
+ src.fPtr.dfs = nullptr;
+ break;
+ case SYMPTR_NS:
+ fPtr.ns = src.fPtr.ns;
+ src.fPtr.ns = nullptr;
+ break;
+ }
+}
+
void SymbolsWrapper::doCleanup() {
switch (fType) {
case SYMPTR_NONE:
@@ -265,53 +577,122 @@ const NumberingSystem* SymbolsWrapper::getNumberingSystem() const {
return fPtr.ns;
}
-LocalizedNumberFormatter::~LocalizedNumberFormatter() {
- delete fCompiled;
-}
-FormattedNumber LocalizedNumberFormatter::formatInt(int64_t value, UErrorCode &status) const {
+FormattedNumber LocalizedNumberFormatter::formatInt(int64_t value, UErrorCode& status) const {
if (U_FAILURE(status)) { return FormattedNumber(U_ILLEGAL_ARGUMENT_ERROR); }
- auto results = new NumberFormatterResults();
+ auto results = new UFormattedNumberData();
if (results == nullptr) {
status = U_MEMORY_ALLOCATION_ERROR;
return FormattedNumber(status);
}
results->quantity.setToLong(value);
- return formatImpl(results, status);
+ formatImpl(results, status);
+
+ // Do not save the results object if we encountered a failure.
+ if (U_SUCCESS(status)) {
+ return FormattedNumber(results);
+ } else {
+ delete results;
+ return FormattedNumber(status);
+ }
}
-FormattedNumber LocalizedNumberFormatter::formatDouble(double value, UErrorCode &status) const {
+FormattedNumber LocalizedNumberFormatter::formatDouble(double value, UErrorCode& status) const {
if (U_FAILURE(status)) { return FormattedNumber(U_ILLEGAL_ARGUMENT_ERROR); }
- auto results = new NumberFormatterResults();
+ auto results = new UFormattedNumberData();
if (results == nullptr) {
status = U_MEMORY_ALLOCATION_ERROR;
return FormattedNumber(status);
}
results->quantity.setToDouble(value);
- return formatImpl(results, status);
+ formatImpl(results, status);
+
+ // Do not save the results object if we encountered a failure.
+ if (U_SUCCESS(status)) {
+ return FormattedNumber(results);
+ } else {
+ delete results;
+ return FormattedNumber(status);
+ }
}
-FormattedNumber LocalizedNumberFormatter::formatDecimal(StringPiece value, UErrorCode &status) const {
+FormattedNumber LocalizedNumberFormatter::formatDecimal(StringPiece value, UErrorCode& status) const {
if (U_FAILURE(status)) { return FormattedNumber(U_ILLEGAL_ARGUMENT_ERROR); }
- auto results = new NumberFormatterResults();
+ auto results = new UFormattedNumberData();
if (results == nullptr) {
status = U_MEMORY_ALLOCATION_ERROR;
return FormattedNumber(status);
}
- results->quantity.setToDecNumber(value);
- return formatImpl(results, status);
+ results->quantity.setToDecNumber(value, status);
+ formatImpl(results, status);
+
+ // Do not save the results object if we encountered a failure.
+ if (U_SUCCESS(status)) {
+ return FormattedNumber(results);
+ } else {
+ delete results;
+ return FormattedNumber(status);
+ }
}
FormattedNumber
-LocalizedNumberFormatter::formatImpl(impl::NumberFormatterResults *results, UErrorCode &status) const {
+LocalizedNumberFormatter::formatDecimalQuantity(const DecimalQuantity& dq, UErrorCode& status) const {
+ if (U_FAILURE(status)) { return FormattedNumber(U_ILLEGAL_ARGUMENT_ERROR); }
+ auto results = new UFormattedNumberData();
+ if (results == nullptr) {
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return FormattedNumber(status);
+ }
+ results->quantity = dq;
+ formatImpl(results, status);
+
+ // Do not save the results object if we encountered a failure.
+ if (U_SUCCESS(status)) {
+ return FormattedNumber(results);
+ } else {
+ delete results;
+ return FormattedNumber(status);
+ }
+}
+
+void LocalizedNumberFormatter::formatImpl(impl::UFormattedNumberData* results, UErrorCode& status) const {
+ if (computeCompiled(status)) {
+ fCompiled->apply(results->quantity, results->string, status);
+ } else {
+ NumberFormatterImpl::applyStatic(fMacros, results->quantity, results->string, status);
+ }
+}
+
+void LocalizedNumberFormatter::getAffixImpl(bool isPrefix, bool isNegative, UnicodeString& result,
+ UErrorCode& status) const {
+ NumberStringBuilder string;
+ auto signum = static_cast<int8_t>(isNegative ? -1 : 1);
+ // Always return affixes for plural form OTHER.
+ static const StandardPlural::Form plural = StandardPlural::OTHER;
+ int32_t prefixLength;
+ if (computeCompiled(status)) {
+ prefixLength = fCompiled->getPrefixSuffix(signum, plural, string, status);
+ } else {
+ prefixLength = NumberFormatterImpl::getPrefixSuffixStatic(fMacros, signum, plural, string, status);
+ }
+ result.remove();
+ if (isPrefix) {
+ result.append(string.toTempUnicodeString().tempSubStringBetween(0, prefixLength));
+ } else {
+ result.append(string.toTempUnicodeString().tempSubStringBetween(prefixLength, string.length()));
+ }
+}
+
+bool LocalizedNumberFormatter::computeCompiled(UErrorCode& status) const {
// fUnsafeCallCount contains memory to be interpreted as an atomic int, most commonly
// std::atomic<int32_t>. Since the type of atomic int is platform-dependent, we cast the
// bytes in fUnsafeCallCount to u_atomic_int32_t, a typedef for the platform-dependent
// atomic int type defined in umutex.h.
- static_assert(sizeof(u_atomic_int32_t) <= sizeof(fUnsafeCallCount),
- "Atomic integer size on this platform exceeds the size allocated by fUnsafeCallCount");
- u_atomic_int32_t* callCount = reinterpret_cast<u_atomic_int32_t*>(
- const_cast<LocalizedNumberFormatter*>(this)->fUnsafeCallCount);
+ static_assert(
+ sizeof(u_atomic_int32_t) <= sizeof(fUnsafeCallCount),
+ "Atomic integer size on this platform exceeds the size allocated by fUnsafeCallCount");
+ auto* callCount = reinterpret_cast<u_atomic_int32_t*>(
+ const_cast<LocalizedNumberFormatter*>(this)->fUnsafeCallCount);
// A positive value in the atomic int indicates that the data structure is not yet ready;
// a negative value indicates that it is ready. If, after the increment, the atomic int
@@ -325,64 +706,144 @@ LocalizedNumberFormatter::formatImpl(impl::NumberFormatterResults *results, UErr
if (currentCount == fMacros.threshold && fMacros.threshold > 0) {
// Build the data structure and then use it (slow to fast path).
- const NumberFormatterImpl* compiled =
- NumberFormatterImpl::fromMacros(fMacros, status);
+ const NumberFormatterImpl* compiled = NumberFormatterImpl::fromMacros(fMacros, status);
U_ASSERT(fCompiled == nullptr);
- const_cast<LocalizedNumberFormatter *>(this)->fCompiled = compiled;
+ const_cast<LocalizedNumberFormatter*>(this)->fCompiled = compiled;
umtx_storeRelease(*callCount, INT32_MIN);
- compiled->apply(results->quantity, results->string, status);
+ return true;
} else if (currentCount < 0) {
// The data structure is already built; use it (fast path).
U_ASSERT(fCompiled != nullptr);
- fCompiled->apply(results->quantity, results->string, status);
+ return true;
} else {
// Format the number without building the data structure (slow path).
- NumberFormatterImpl::applyStatic(fMacros, results->quantity, results->string, status);
+ return false;
}
+}
- // Do not save the results object if we encountered a failure.
- if (U_SUCCESS(status)) {
- return FormattedNumber(results);
- } else {
- delete results;
- return FormattedNumber(status);
- }
+const impl::NumberFormatterImpl* LocalizedNumberFormatter::getCompiled() const {
+ return fCompiled;
+}
+
+int32_t LocalizedNumberFormatter::getCallCount() const {
+ auto* callCount = reinterpret_cast<u_atomic_int32_t*>(
+ const_cast<LocalizedNumberFormatter*>(this)->fUnsafeCallCount);
+ return umtx_loadAcquire(*callCount);
+}
+
+Format* LocalizedNumberFormatter::toFormat(UErrorCode& status) const {
+ LocalPointer<LocalizedNumberFormatterAsFormat> retval(
+ new LocalizedNumberFormatterAsFormat(*this, fMacros.locale), status);
+ return retval.orphan();
+}
+
+
+FormattedNumber::FormattedNumber(FormattedNumber&& src) U_NOEXCEPT
+ : fResults(src.fResults), fErrorCode(src.fErrorCode) {
+ // Disown src.fResults to prevent double-deletion
+ src.fResults = nullptr;
+ src.fErrorCode = U_INVALID_STATE_ERROR;
+}
+
+FormattedNumber& FormattedNumber::operator=(FormattedNumber&& src) U_NOEXCEPT {
+ delete fResults;
+ fResults = src.fResults;
+ fErrorCode = src.fErrorCode;
+ // Disown src.fResults to prevent double-deletion
+ src.fResults = nullptr;
+ src.fErrorCode = U_INVALID_STATE_ERROR;
+ return *this;
}
UnicodeString FormattedNumber::toString() const {
+ UErrorCode localStatus = U_ZERO_ERROR;
+ return toString(localStatus);
+}
+
+UnicodeString FormattedNumber::toString(UErrorCode& status) const {
+ if (U_FAILURE(status)) {
+ return ICU_Utility::makeBogusString();
+ }
if (fResults == nullptr) {
- // TODO: http://bugs.icu-project.org/trac/ticket/13437
- return {};
+ status = fErrorCode;
+ return ICU_Utility::makeBogusString();
}
return fResults->string.toUnicodeString();
}
-Appendable &FormattedNumber::appendTo(Appendable &appendable) {
+Appendable& FormattedNumber::appendTo(Appendable& appendable) {
+ UErrorCode localStatus = U_ZERO_ERROR;
+ return appendTo(appendable, localStatus);
+}
+
+Appendable& FormattedNumber::appendTo(Appendable& appendable, UErrorCode& status) {
+ if (U_FAILURE(status)) {
+ return appendable;
+ }
if (fResults == nullptr) {
- // TODO: http://bugs.icu-project.org/trac/ticket/13437
+ status = fErrorCode;
return appendable;
}
appendable.appendString(fResults->string.chars(), fResults->string.length());
return appendable;
}
-void FormattedNumber::populateFieldPosition(FieldPosition &fieldPosition, UErrorCode &status) {
- if (U_FAILURE(status)) { return; }
+void FormattedNumber::populateFieldPosition(FieldPosition& fieldPosition, UErrorCode& status) {
+ if (U_FAILURE(status)) {
+ return;
+ }
+ if (fResults == nullptr) {
+ status = fErrorCode;
+ return;
+ }
+ // in case any users were depending on the old behavior:
+ fieldPosition.setBeginIndex(0);
+ fieldPosition.setEndIndex(0);
+ fResults->string.nextFieldPosition(fieldPosition, status);
+}
+
+UBool FormattedNumber::nextFieldPosition(FieldPosition& fieldPosition, UErrorCode& status) const {
+ if (U_FAILURE(status)) {
+ return FALSE;
+ }
+ if (fResults == nullptr) {
+ status = fErrorCode;
+ return FALSE;
+ }
+ // NOTE: MSVC sometimes complains when implicitly converting between bool and UBool
+ return fResults->string.nextFieldPosition(fieldPosition, status) ? TRUE : FALSE;
+}
+
+void FormattedNumber::populateFieldPositionIterator(FieldPositionIterator& iterator, UErrorCode& status) {
+ getAllFieldPositions(iterator, status);
+}
+
+void FormattedNumber::getAllFieldPositions(FieldPositionIterator& iterator, UErrorCode& status) const {
+ FieldPositionIteratorHandler fpih(&iterator, status);
+ getAllFieldPositionsImpl(fpih, status);
+}
+
+void FormattedNumber::getAllFieldPositionsImpl(FieldPositionIteratorHandler& fpih,
+ UErrorCode& status) const {
+ if (U_FAILURE(status)) {
+ return;
+ }
if (fResults == nullptr) {
status = fErrorCode;
return;
}
- fResults->string.populateFieldPosition(fieldPosition, 0, status);
+ fResults->string.getAllFieldPositions(fpih, status);
}
-void
-FormattedNumber::populateFieldPositionIterator(FieldPositionIterator &iterator, UErrorCode &status) {
- if (U_FAILURE(status)) { return; }
+void FormattedNumber::getDecimalQuantity(DecimalQuantity& output, UErrorCode& status) const {
+ if (U_FAILURE(status)) {
+ return;
+ }
if (fResults == nullptr) {
status = fErrorCode;
return;
}
- fResults->string.populateFieldPositionIterator(iterator, status);
+ output = fResults->quantity;
}
FormattedNumber::~FormattedNumber() {
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-14 20:24:34 +0000