| // © 2017 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| |
| #include "unicode/utypes.h" |
| |
| #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 copy(*this); |
| // NOTE: Slicing is OK. |
| copy.fMacros.notation = notation; |
| return copy; |
| } |
| |
| template<typename Derived> |
| 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. |
| copy.fMacros.unit = unit; |
| return copy; |
| } |
| |
| template<typename Derived> |
| 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 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 = std::move(*unit); |
| delete unit; |
| } |
| return copy; |
| } |
| |
| template<typename Derived> |
| 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; |
| return copy; |
| } |
| |
| template<typename Derived> |
| 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 = std::move(*perUnit); |
| delete perUnit; |
| } |
| return copy; |
| } |
| |
| template<typename Derived> |
| 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.precision = precision; |
| return copy; |
| } |
| |
| template<typename Derived> |
| 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. |
| copy.fMacros.grouper = Grouper::forStrategy(strategy); |
| return copy; |
| } |
| |
| template<typename Derived> |
| 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>::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>::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>::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>::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>::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>::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>::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 |
| class icu::number::NumberFormatterSettings<icu::number::UnlocalizedNumberFormatter>; |
| template |
| class icu::number::NumberFormatterSettings<icu::number::LocalizedNumberFormatter>; |
| |
| |
| UnlocalizedNumberFormatter NumberFormatter::with() { |
| UnlocalizedNumberFormatter result; |
| return result; |
| } |
| |
| LocalizedNumberFormatter NumberFormatter::withLocale(const Locale& locale) { |
| return with().locale(locale); |
| } |
| |
| 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; |
| } |
| |
| |
| LocalizedNumberFormatter::~LocalizedNumberFormatter() { |
| delete fCompiled; |
| } |
| |
| LocalizedNumberFormatter::LocalizedNumberFormatter(const MacroProps& macros, const Locale& locale) { |
| fMacros = macros; |
| fMacros.locale = locale; |
| } |
| |
| 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); |
| } |
| |
| LocalizedNumberFormatter UnlocalizedNumberFormatter::locale(const Locale& locale)&& { |
| return LocalizedNumberFormatter(std::move(fMacros), locale); |
| } |
| |
| SymbolsWrapper::SymbolsWrapper(const SymbolsWrapper& other) { |
| doCopyFrom(other); |
| } |
| |
| SymbolsWrapper::SymbolsWrapper(SymbolsWrapper&& src) U_NOEXCEPT { |
| doMoveFrom(std::move(src)); |
| } |
| |
| SymbolsWrapper& SymbolsWrapper::operator=(const SymbolsWrapper& other) { |
| if (this == &other) { |
| return *this; |
| } |
| doCleanup(); |
| doCopyFrom(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) { |
| doCleanup(); |
| fType = SYMPTR_DFS; |
| fPtr.dfs = new DecimalFormatSymbols(dfs); |
| } |
| |
| void SymbolsWrapper::setTo(const NumberingSystem* ns) { |
| doCleanup(); |
| fType = SYMPTR_NS; |
| fPtr.ns = ns; |
| } |
| |
| void SymbolsWrapper::doCopyFrom(const SymbolsWrapper& other) { |
| fType = other.fType; |
| switch (fType) { |
| case SYMPTR_NONE: |
| // No action necessary |
| break; |
| case SYMPTR_DFS: |
| // Memory allocation failures are exposed in copyErrorTo() |
| if (other.fPtr.dfs != nullptr) { |
| fPtr.dfs = new DecimalFormatSymbols(*other.fPtr.dfs); |
| } else { |
| fPtr.dfs = nullptr; |
| } |
| break; |
| case SYMPTR_NS: |
| // Memory allocation failures are exposed in copyErrorTo() |
| if (other.fPtr.ns != nullptr) { |
| fPtr.ns = new NumberingSystem(*other.fPtr.ns); |
| } else { |
| fPtr.ns = nullptr; |
| } |
| break; |
| } |
| } |
| |
| 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: |
| // No action necessary |
| break; |
| case SYMPTR_DFS: |
| delete fPtr.dfs; |
| break; |
| case SYMPTR_NS: |
| delete fPtr.ns; |
| break; |
| } |
| } |
| |
| bool SymbolsWrapper::isDecimalFormatSymbols() const { |
| return fType == SYMPTR_DFS; |
| } |
| |
| bool SymbolsWrapper::isNumberingSystem() const { |
| return fType == SYMPTR_NS; |
| } |
| |
| const DecimalFormatSymbols* SymbolsWrapper::getDecimalFormatSymbols() const { |
| U_ASSERT(fType == SYMPTR_DFS); |
| return fPtr.dfs; |
| } |
| |
| const NumberingSystem* SymbolsWrapper::getNumberingSystem() const { |
| U_ASSERT(fType == SYMPTR_NS); |
| return fPtr.ns; |
| } |
| |
| |
| FormattedNumber LocalizedNumberFormatter::formatInt(int64_t value, 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.setToLong(value); |
| 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 { |
| 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.setToDouble(value); |
| 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 { |
| 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.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::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"); |
| 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 |
| // is exactly threshold, then it is the current thread's job to build the data structure. |
| // Note: We set the callCount to INT32_MIN so that if another thread proceeds to increment |
| // the atomic int, the value remains below zero. |
| int32_t currentCount = umtx_loadAcquire(*callCount); |
| if (0 <= currentCount && currentCount <= fMacros.threshold && fMacros.threshold > 0) { |
| currentCount = umtx_atomic_inc(callCount); |
| } |
| |
| 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); |
| U_ASSERT(fCompiled == nullptr); |
| const_cast<LocalizedNumberFormatter*>(this)->fCompiled = compiled; |
| umtx_storeRelease(*callCount, INT32_MIN); |
| return true; |
| } else if (currentCount < 0) { |
| // The data structure is already built; use it (fast path). |
| U_ASSERT(fCompiled != nullptr); |
| return true; |
| } else { |
| // Format the number without building the data structure (slow path). |
| return false; |
| } |
| } |
| |
| 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) { |
| status = fErrorCode; |
| return ICU_Utility::makeBogusString(); |
| } |
| return fResults->string.toUnicodeString(); |
| } |
| |
| 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) { |
| 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; |
| } |
| 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.getAllFieldPositions(fpih, status); |
| } |
| |
| void FormattedNumber::getDecimalQuantity(DecimalQuantity& output, UErrorCode& status) const { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| if (fResults == nullptr) { |
| status = fErrorCode; |
| return; |
| } |
| output = fResults->quantity; |
| } |
| |
| FormattedNumber::~FormattedNumber() { |
| delete fResults; |
| } |
| |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |