numberformatter.h

Go to the documentation of this file.

// © 2017 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html

#ifndef __NUMBERFORMATTER_H__
#define __NUMBERFORMATTER_H__

#include "unicode/utypes.h"

#if U_SHOW_CPLUSPLUS_API

#if !UCONFIG_NO_FORMATTING

#include "unicode/appendable.h"
#include "unicode/bytestream.h"
#include "unicode/currunit.h"
#include "unicode/dcfmtsym.h"
#include "unicode/displayoptions.h"
#include "unicode/fieldpos.h"
#include "unicode/fpositer.h"
#include "unicode/measunit.h"
#include "unicode/nounit.h"
#include "unicode/parseerr.h"
#include "unicode/plurrule.h"
#include "unicode/ucurr.h"
#include "unicode/unum.h"
#include "unicode/unumberformatter.h"
#include "unicode/uobject.h"
#include "unicode/unumberoptions.h"
#include "unicode/formattednumber.h"

U_NAMESPACE_BEGIN

// Forward declarations:
class IFixedDecimal;
class FieldPositionIteratorHandler;
class FormattedStringBuilder;

namespace numparse {
namespace impl {

// Forward declarations:
class NumberParserImpl;
class MultiplierParseHandler;

}
}

namespace units {

// Forward declarations:
class UnitsRouter;

} // namespace units

namespace number {  // icu::number

// Forward declarations:
class UnlocalizedNumberFormatter;
class LocalizedNumberFormatter;
class SimpleNumberFormatter;
class FormattedNumber;
class Notation;
class ScientificNotation;
class Precision;
class FractionPrecision;
class CurrencyPrecision;
class IncrementPrecision;
class IntegerWidth;

namespace impl {

// can't be #ifndef U_HIDE_INTERNAL_API; referenced throughout this file in public classes
typedef int16_t digits_t;

// can't be #ifndef U_HIDE_INTERNAL_API; needed for struct initialization
static constexpr int32_t kInternalDefaultThreshold = 3;

// Forward declarations:
class Padder;
struct MacroProps;
struct MicroProps;
class DecimalQuantity;
class UFormattedNumberData;
class NumberFormatterImpl;
struct ParsedPatternInfo;
class ScientificModifier;
class MultiplierProducer;
class RoundingImpl;
class ScientificHandler;
class Modifier;
class AffixPatternProvider;
class NumberPropertyMapper;
struct DecimalFormatProperties;
class MultiplierFormatHandler;
class CurrencySymbols;
class GeneratorHelpers;
class DecNum;
class NumberRangeFormatterImpl;
struct RangeMacroProps;
struct UFormattedNumberImpl;
class MutablePatternModifier;
class ImmutablePatternModifier;
struct DecimalFormatWarehouse;
struct SimpleMicroProps;
class AdoptingSignumModifierStore;

void touchRangeLocales(impl::RangeMacroProps& macros);

} // namespace impl

typedef Notation CompactNotation;

typedef Notation SimpleNotation;

class U_I18N_API Notation : public UMemory {
  public:
    static ScientificNotation scientific();

    static ScientificNotation engineering();

    static CompactNotation compactShort();

    static CompactNotation compactLong();

    static SimpleNotation simple();

  private:
    enum NotationType {
        NTN_SCIENTIFIC, NTN_COMPACT, NTN_SIMPLE, NTN_ERROR
    } fType;

    union NotationUnion {
        // For NTN_SCIENTIFIC
        struct ScientificSettings {
            int8_t fEngineeringInterval;
            bool fRequireMinInt;
            impl::digits_t fMinExponentDigits;
            UNumberSignDisplay fExponentSignDisplay;
        } scientific;

        // For NTN_COMPACT
        UNumberCompactStyle compactStyle;

        // For NTN_ERROR
        UErrorCode errorCode;
    } fUnion;

    typedef NotationUnion::ScientificSettings ScientificSettings;

    Notation(const NotationType &type, const NotationUnion &union_) : fType(type), fUnion(union_) {}

    Notation(UErrorCode errorCode) : fType(NTN_ERROR) {
        fUnion.errorCode = errorCode;
    }

    Notation() : fType(NTN_SIMPLE), fUnion() {}

    UBool copyErrorTo(UErrorCode &status) const {
        if (fType == NTN_ERROR) {
            status = fUnion.errorCode;
            return true;
        }
        return false;
    }

    // To allow MacroProps to initialize empty instances:
    friend struct impl::MacroProps;
    friend class ScientificNotation;

    // To allow implementation to access internal types:
    friend class impl::NumberFormatterImpl;
    friend class impl::ScientificModifier;
    friend class impl::ScientificHandler;

    // To allow access to the skeleton generation code:
    friend class impl::GeneratorHelpers;
};

class U_I18N_API ScientificNotation : public Notation {
  public:
    ScientificNotation withMinExponentDigits(int32_t minExponentDigits) const;

    ScientificNotation withExponentSignDisplay(UNumberSignDisplay exponentSignDisplay) const;

  private:
    // Inherit constructor
    using Notation::Notation;

    // Raw constructor for NumberPropertyMapper
    ScientificNotation(int8_t fEngineeringInterval, bool fRequireMinInt, impl::digits_t fMinExponentDigits,
                       UNumberSignDisplay fExponentSignDisplay);

    friend class Notation;

    // So that NumberPropertyMapper can create instances
    friend class impl::NumberPropertyMapper;
};

typedef Precision SignificantDigitsPrecision;

class U_I18N_API Precision : public UMemory {

  public:
    static Precision unlimited();

    static FractionPrecision integer();

    static FractionPrecision fixedFraction(int32_t minMaxFractionPlaces);

    static FractionPrecision minFraction(int32_t minFractionPlaces);

    static FractionPrecision maxFraction(int32_t maxFractionPlaces);

    static FractionPrecision minMaxFraction(int32_t minFractionPlaces, int32_t maxFractionPlaces);

    static SignificantDigitsPrecision fixedSignificantDigits(int32_t minMaxSignificantDigits);

    static SignificantDigitsPrecision minSignificantDigits(int32_t minSignificantDigits);

    static SignificantDigitsPrecision maxSignificantDigits(int32_t maxSignificantDigits);

    static SignificantDigitsPrecision minMaxSignificantDigits(int32_t minSignificantDigits,
                                                              int32_t maxSignificantDigits);

    static IncrementPrecision increment(double roundingIncrement);

    static IncrementPrecision incrementExact(uint64_t mantissa, int16_t magnitude);

    static CurrencyPrecision currency(UCurrencyUsage currencyUsage);

    Precision trailingZeroDisplay(UNumberTrailingZeroDisplay trailingZeroDisplay) const;

  private:
    enum PrecisionType {
        RND_BOGUS,
        RND_NONE,
        RND_FRACTION,
        RND_SIGNIFICANT,
        RND_FRACTION_SIGNIFICANT,

        // Used for strange increments like 3.14.
        RND_INCREMENT,

        // Used for increments with 1 as the only digit. This is different than fraction
        // rounding because it supports having additional trailing zeros. For example, this
        // class is used to round with the increment 0.010.
        RND_INCREMENT_ONE,

        // Used for increments with 5 as the only digit (nickel rounding).
        RND_INCREMENT_FIVE,

        RND_CURRENCY,
        RND_ERROR
    } fType;

    union PrecisionUnion {
        struct FractionSignificantSettings {
            // For RND_FRACTION, RND_SIGNIFICANT, and RND_FRACTION_SIGNIFICANT
            impl::digits_t fMinFrac;
            impl::digits_t fMaxFrac;
            impl::digits_t fMinSig;
            impl::digits_t fMaxSig;
            UNumberRoundingPriority fPriority;
            bool fRetain;
        } fracSig;
        struct IncrementSettings {
            // For RND_INCREMENT, RND_INCREMENT_ONE, and RND_INCREMENT_FIVE
            // Note: This is a union, so we shouldn't own memory, since
            // the default destructor would leak it.
            uint64_t fIncrement;
            impl::digits_t fIncrementMagnitude;
            impl::digits_t fMinFrac;
        } increment;
        UCurrencyUsage currencyUsage; // For RND_CURRENCY
        UErrorCode errorCode; // For RND_ERROR
    } fUnion;

    UNumberTrailingZeroDisplay fTrailingZeroDisplay = UNUM_TRAILING_ZERO_AUTO;

    typedef PrecisionUnion::FractionSignificantSettings FractionSignificantSettings;
    typedef PrecisionUnion::IncrementSettings IncrementSettings;

    Precision(const PrecisionType& type, const PrecisionUnion& union_)
            : fType(type), fUnion(union_) {}

    Precision(UErrorCode errorCode) : fType(RND_ERROR) {
        fUnion.errorCode = errorCode;
    }

    Precision() : fType(RND_BOGUS) {}

    bool isBogus() const {
        return fType == RND_BOGUS;
    }

    UBool copyErrorTo(UErrorCode &status) const {
        if (fType == RND_ERROR) {
            status = fUnion.errorCode;
            return true;
        }
        return false;
    }

    // On the parent type so that this method can be called internally on Precision instances.
    Precision withCurrency(const CurrencyUnit &currency, UErrorCode &status) const;

    static FractionPrecision constructFraction(int32_t minFrac, int32_t maxFrac);

    static Precision constructSignificant(int32_t minSig, int32_t maxSig);

    static Precision constructFractionSignificant(
        const FractionPrecision &base,
        int32_t minSig,
        int32_t maxSig,
        UNumberRoundingPriority priority,
        bool retain);

    static IncrementPrecision constructIncrement(uint64_t increment, impl::digits_t magnitude);

    static CurrencyPrecision constructCurrency(UCurrencyUsage usage);

    // To allow MacroProps/MicroProps to initialize bogus instances:
    friend struct impl::MacroProps;
    friend struct impl::MicroProps;

    // To allow NumberFormatterImpl to access isBogus() and other internal methods:
    friend class impl::NumberFormatterImpl;

    // To allow NumberPropertyMapper to create instances from DecimalFormatProperties:
    friend class impl::NumberPropertyMapper;

    // To allow access to the main implementation class:
    friend class impl::RoundingImpl;

    // To allow child classes to call private methods:
    friend class FractionPrecision;
    friend class CurrencyPrecision;
    friend class IncrementPrecision;

    // To allow access to the skeleton generation code:
    friend class impl::GeneratorHelpers;

    // To allow access to isBogus and the default (bogus) constructor:
    friend class units::UnitsRouter;
};

class U_I18N_API FractionPrecision : public Precision {
  public:
    Precision withSignificantDigits(
        int32_t minSignificantDigits,
        int32_t maxSignificantDigits,
        UNumberRoundingPriority priority) const;

    Precision withMinDigits(int32_t minSignificantDigits) const;

    Precision withMaxDigits(int32_t maxSignificantDigits) const;

  private:
    // Inherit constructor
    using Precision::Precision;

    // To allow parent class to call this class's constructor:
    friend class Precision;
};

class U_I18N_API CurrencyPrecision : public Precision {
  public:
    Precision withCurrency(const CurrencyUnit &currency) const;

  private:
    // Inherit constructor
    using Precision::Precision;

    // To allow parent class to call this class's constructor:
    friend class Precision;
};

class U_I18N_API IncrementPrecision : public Precision {
  public:
    Precision withMinFraction(int32_t minFrac) const;

  private:
    // Inherit constructor
    using Precision::Precision;

    // To allow parent class to call this class's constructor:
    friend class Precision;
};

class U_I18N_API IntegerWidth : public UMemory {
  public:
    static IntegerWidth zeroFillTo(int32_t minInt);

    IntegerWidth truncateAt(int32_t maxInt);

  private:
    union {
        struct {
            impl::digits_t fMinInt;
            impl::digits_t fMaxInt;
            bool fFormatFailIfMoreThanMaxDigits;
        } minMaxInt;
        UErrorCode errorCode;
    } fUnion;
    bool fHasError = false;

    IntegerWidth(impl::digits_t minInt, impl::digits_t maxInt, bool formatFailIfMoreThanMaxDigits);

    IntegerWidth(UErrorCode errorCode) { // NOLINT
        fUnion.errorCode = errorCode;
        fHasError = true;
    }

    IntegerWidth() { // NOLINT
        fUnion.minMaxInt.fMinInt = -1;
    }

    static IntegerWidth standard() {
        return IntegerWidth::zeroFillTo(1);
    }

    bool isBogus() const {
        return !fHasError && fUnion.minMaxInt.fMinInt == -1;
    }

    UBool copyErrorTo(UErrorCode &status) const {
        if (fHasError) {
            status = fUnion.errorCode;
            return true;
        }
        return false;
    }

    void apply(impl::DecimalQuantity &quantity, UErrorCode &status) const;

    bool operator==(const IntegerWidth& other) const;

    // To allow MacroProps/MicroProps to initialize empty instances:
    friend struct impl::MacroProps;
    friend struct impl::MicroProps;

    // To allow NumberFormatterImpl to access isBogus():
    friend class impl::NumberFormatterImpl;

    // To allow the use of this class when formatting:
    friend class impl::MutablePatternModifier;
    friend class impl::ImmutablePatternModifier;

    // So that NumberPropertyMapper can create instances
    friend class impl::NumberPropertyMapper;

    // To allow access to the skeleton generation code:
    friend class impl::GeneratorHelpers;
};

class U_I18N_API Scale : public UMemory {
  public:
    static Scale none();

    static Scale powerOfTen(int32_t power);

    static Scale byDecimal(StringPiece multiplicand);

    static Scale byDouble(double multiplicand);

    static Scale byDoubleAndPowerOfTen(double multiplicand, int32_t power);

    // We need a custom destructor for the DecNum, which means we need to declare
    // the copy/move constructor/assignment quartet.

    Scale(const Scale& other);

    Scale& operator=(const Scale& other);

    Scale(Scale&& src) noexcept;

    Scale& operator=(Scale&& src) noexcept;

    ~Scale();

#ifndef U_HIDE_INTERNAL_API

    Scale(int32_t magnitude, impl::DecNum* arbitraryToAdopt);
#endif  /* U_HIDE_INTERNAL_API */

  private:
    int32_t fMagnitude;
    impl::DecNum* fArbitrary;
    UErrorCode fError;

    Scale(UErrorCode error) : fMagnitude(0), fArbitrary(nullptr), fError(error) {}

    Scale() : fMagnitude(0), fArbitrary(nullptr), fError(U_ZERO_ERROR) {}

    bool isValid() const {
        return fMagnitude != 0 || fArbitrary != nullptr;
    }

    UBool copyErrorTo(UErrorCode &status) const {
        if (U_FAILURE(fError)) {
            status = fError;
            return true;
        }
        return false;
    }

    void applyTo(impl::DecimalQuantity& quantity) const;

    void applyReciprocalTo(impl::DecimalQuantity& quantity) const;

    // To allow MacroProps/MicroProps to initialize empty instances:
    friend struct impl::MacroProps;
    friend struct impl::MicroProps;

    // To allow NumberFormatterImpl to access isBogus() and perform other operations:
    friend class impl::NumberFormatterImpl;

    // To allow the helper class MultiplierFormatHandler access to private fields:
    friend class impl::MultiplierFormatHandler;

    // To allow access to the skeleton generation code:
    friend class impl::GeneratorHelpers;

    // To allow access to parsing code:
    friend class ::icu::numparse::impl::NumberParserImpl;
    friend class ::icu::numparse::impl::MultiplierParseHandler;
};

namespace impl {

// Do not enclose entire StringProp with #ifndef U_HIDE_INTERNAL_API, needed for a protected field.
// And do not enclose its class boilerplate within #ifndef U_HIDE_INTERNAL_API.
class U_I18N_API StringProp : public UMemory {

  public:
    ~StringProp();

    StringProp(const StringProp &other);

    StringProp &operator=(const StringProp &other);

#ifndef U_HIDE_INTERNAL_API

    StringProp(StringProp &&src) noexcept;

    StringProp &operator=(StringProp &&src) noexcept;

    int16_t length() const {
        return fLength;
    }

    void set(StringPiece value);

    bool isSet() const {
        return fLength > 0;
    }

#endif // U_HIDE_INTERNAL_API

  private:
    char *fValue;
    int16_t fLength;
    UErrorCode fError;

    StringProp() : fValue(nullptr), fLength(0), fError(U_ZERO_ERROR) {
    }

    UBool copyErrorTo(UErrorCode &status) const {
        if (U_FAILURE(fError)) {
            status = fError;
            return true;
        }
        return false;
    }

    // Allow NumberFormatterImpl to access fValue.
    friend class impl::NumberFormatterImpl;

    // Allow skeleton generation code to access private members.
    friend class impl::GeneratorHelpers;

    // Allow MacroProps/MicroProps to initialize empty instances and to call
    // copyErrorTo().
    friend struct impl::MacroProps;
};

// Do not enclose entire SymbolsWrapper with #ifndef U_HIDE_INTERNAL_API, needed for a protected field
class U_I18N_API SymbolsWrapper : public UMemory {
  public:
    SymbolsWrapper() : fType(SYMPTR_NONE), fPtr{nullptr} {}

    SymbolsWrapper(const SymbolsWrapper &other);

    SymbolsWrapper &operator=(const SymbolsWrapper &other);

    SymbolsWrapper(SymbolsWrapper&& src) noexcept;

    SymbolsWrapper &operator=(SymbolsWrapper&& src) noexcept;

    ~SymbolsWrapper();

#ifndef U_HIDE_INTERNAL_API

    void setTo(const DecimalFormatSymbols &dfs);

    void setTo(const NumberingSystem *ns);

    bool isDecimalFormatSymbols() const;

    bool isNumberingSystem() const;

    const DecimalFormatSymbols *getDecimalFormatSymbols() const;

    const NumberingSystem *getNumberingSystem() const;

#endif  // U_HIDE_INTERNAL_API

    UBool copyErrorTo(UErrorCode &status) const {
        if (fType == SYMPTR_DFS && fPtr.dfs == nullptr) {
            status = U_MEMORY_ALLOCATION_ERROR;
            return true;
        } else if (fType == SYMPTR_NS && fPtr.ns == nullptr) {
            status = U_MEMORY_ALLOCATION_ERROR;
            return true;
        }
        return false;
    }

  private:
    enum SymbolsPointerType {
        SYMPTR_NONE, SYMPTR_DFS, SYMPTR_NS
    } fType;

    union {
        const DecimalFormatSymbols *dfs;
        const NumberingSystem *ns;
    } fPtr;

    void doCopyFrom(const SymbolsWrapper &other);

    void doMoveFrom(SymbolsWrapper&& src);

    void doCleanup();
};

// Do not enclose entire Grouper with #ifndef U_HIDE_INTERNAL_API, needed for a protected field
class U_I18N_API Grouper : public UMemory {
  public:
#ifndef U_HIDE_INTERNAL_API

    static Grouper forStrategy(UNumberGroupingStrategy grouping);

    static Grouper forProperties(const DecimalFormatProperties& properties);

    // Future: static Grouper forProperties(DecimalFormatProperties& properties);

    Grouper(int16_t grouping1, int16_t grouping2, int16_t minGrouping, UNumberGroupingStrategy strategy)
            : fGrouping1(grouping1),
              fGrouping2(grouping2),
              fMinGrouping(minGrouping),
              fStrategy(strategy) {}

    int16_t getPrimary() const;

    int16_t getSecondary() const;
#endif  // U_HIDE_INTERNAL_API

  private:
    int16_t fGrouping1;
    int16_t fGrouping2;

    int16_t fMinGrouping;

    UNumberGroupingStrategy fStrategy;

    Grouper() : fGrouping1(-3) {}

    bool isBogus() const {
        return fGrouping1 == -3;
    }

    void setLocaleData(const impl::ParsedPatternInfo &patternInfo, const Locale& locale);

    bool groupAtPosition(int32_t position, const impl::DecimalQuantity &value) const;

    // To allow MacroProps/MicroProps to initialize empty instances:
    friend struct MacroProps;
    friend struct MicroProps;
    friend struct SimpleMicroProps;

    // To allow NumberFormatterImpl to access isBogus() and perform other operations:
    friend class NumberFormatterImpl;
    friend class ::icu::number::SimpleNumberFormatter;

    // To allow NumberParserImpl to perform setLocaleData():
    friend class ::icu::numparse::impl::NumberParserImpl;

    // To allow access to the skeleton generation code:
    friend class impl::GeneratorHelpers;
};

// Do not enclose entire Padder with #ifndef U_HIDE_INTERNAL_API, needed for a protected field
class U_I18N_API Padder : public UMemory {
  public:
#ifndef U_HIDE_INTERNAL_API

    static Padder none();

    static Padder codePoints(UChar32 cp, int32_t targetWidth, UNumberFormatPadPosition position);

    static Padder forProperties(const DecimalFormatProperties& properties);
#endif  // U_HIDE_INTERNAL_API

  private:
    UChar32 fWidth;  // -3 = error; -2 = bogus; -1 = no padding
    union {
        struct {
            int32_t fCp;
            UNumberFormatPadPosition fPosition;
        } padding;
        UErrorCode errorCode;
    } fUnion;

    Padder(UChar32 cp, int32_t width, UNumberFormatPadPosition position);

    Padder(int32_t width);

    Padder(UErrorCode errorCode) : fWidth(-3) { // NOLINT
        fUnion.errorCode = errorCode;
    }

    Padder() : fWidth(-2) {} // NOLINT

    bool isBogus() const {
        return fWidth == -2;
    }

    UBool copyErrorTo(UErrorCode &status) const {
        if (fWidth == -3) {
            status = fUnion.errorCode;
            return true;
        }
        return false;
    }

    bool isValid() const {
        return fWidth > 0;
    }

    int32_t padAndApply(const impl::Modifier &mod1, const impl::Modifier &mod2,
                        FormattedStringBuilder &string, int32_t leftIndex, int32_t rightIndex,
                        UErrorCode &status) const;

    // To allow MacroProps/MicroProps to initialize empty instances:
    friend struct MacroProps;
    friend struct MicroProps;

    // To allow NumberFormatterImpl to access isBogus() and perform other operations:
    friend class impl::NumberFormatterImpl;

    // To allow access to the skeleton generation code:
    friend class impl::GeneratorHelpers;
};

// Do not enclose entire MacroProps with #ifndef U_HIDE_INTERNAL_API, needed for a protected field
struct U_I18N_API MacroProps : public UMemory {
    Notation notation;

    MeasureUnit unit;  // = MeasureUnit();  (the base dimensionless unit)

    MeasureUnit perUnit;  // = MeasureUnit();  (the base dimensionless unit)

    Precision precision;  // = Precision();  (bogus)

    UNumberFormatRoundingMode roundingMode = UNUM_ROUND_HALFEVEN;

    Grouper grouper;  // = Grouper();  (bogus)

    Padder padder;    // = Padder();   (bogus)

    IntegerWidth integerWidth; // = IntegerWidth(); (bogus)

    SymbolsWrapper symbols;

    // UNUM_XYZ_COUNT denotes null (bogus) values.

    UNumberUnitWidth unitWidth = UNUM_UNIT_WIDTH_COUNT;

    UNumberSignDisplay sign = UNUM_SIGN_COUNT;

    bool approximately = false;

    UNumberDecimalSeparatorDisplay decimal = UNUM_DECIMAL_SEPARATOR_COUNT;

    Scale scale;  // = Scale();  (benign value)

    StringProp usage;  // = StringProp();  (no usage)

    StringProp unitDisplayCase;  // = StringProp();  (nominative)

    const AffixPatternProvider* affixProvider = nullptr;  // no ownership

    const PluralRules* rules = nullptr;  // no ownership

    int32_t threshold = kInternalDefaultThreshold;

    Locale locale;

    // NOTE: Uses default copy and move constructors.

    bool copyErrorTo(UErrorCode &status) const {
        return notation.copyErrorTo(status) || precision.copyErrorTo(status) ||
               padder.copyErrorTo(status) || integerWidth.copyErrorTo(status) ||
               symbols.copyErrorTo(status) || scale.copyErrorTo(status) || usage.copyErrorTo(status) ||
               unitDisplayCase.copyErrorTo(status);
    }
};

} // namespace impl

#if (U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN) && defined(_MSC_VER)
// Ignore MSVC warning 4661. This is generated for NumberFormatterSettings<>::toSkeleton() as this method
// is defined elsewhere (in number_skeletons.cpp). The compiler is warning that the explicit template instantiation
// inside this single translation unit (CPP file) is incomplete, and thus it isn't sure if the template class is
// fully defined. However, since each translation unit explicitly instantiates all the necessary template classes,
// they will all be passed to the linker, and the linker will still find and export all the class members.
#pragma warning(push)
#pragma warning(disable: 4661)
#endif

template<typename Derived>
class U_I18N_API NumberFormatterSettings {
  public:
    Derived notation(const Notation &notation) const &;

    Derived notation(const Notation &notation) &&;

    Derived unit(const icu::MeasureUnit &unit) const &;

    Derived unit(const icu::MeasureUnit &unit) &&;

    Derived adoptUnit(icu::MeasureUnit *unit) const &;

    Derived adoptUnit(icu::MeasureUnit *unit) &&;

    Derived perUnit(const icu::MeasureUnit &perUnit) const &;

    Derived perUnit(const icu::MeasureUnit &perUnit) &&;

    Derived adoptPerUnit(icu::MeasureUnit *perUnit) const &;

    Derived adoptPerUnit(icu::MeasureUnit *perUnit) &&;

    Derived precision(const Precision& precision) const &;

    Derived precision(const Precision& precision) &&;

    Derived roundingMode(UNumberFormatRoundingMode roundingMode) const &;

    Derived roundingMode(UNumberFormatRoundingMode roundingMode) &&;

    Derived grouping(UNumberGroupingStrategy strategy) const &;

    Derived grouping(UNumberGroupingStrategy strategy) &&;

    Derived integerWidth(const IntegerWidth &style) const &;

    Derived integerWidth(const IntegerWidth &style) &&;

    Derived symbols(const DecimalFormatSymbols &symbols) const &;

    Derived symbols(const DecimalFormatSymbols &symbols) &&;

    Derived adoptSymbols(NumberingSystem *symbols) const &;

    Derived adoptSymbols(NumberingSystem *symbols) &&;

    Derived unitWidth(UNumberUnitWidth width) const &;

    Derived unitWidth(UNumberUnitWidth width) &&;

    Derived sign(UNumberSignDisplay style) const &;

    Derived sign(UNumberSignDisplay style) &&;

    Derived decimal(UNumberDecimalSeparatorDisplay style) const &;

    Derived decimal(UNumberDecimalSeparatorDisplay style) &&;

    Derived scale(const Scale &scale) const &;

    Derived scale(const Scale &scale) &&;

    Derived usage(StringPiece usage) const &;

    Derived usage(StringPiece usage) &&;

#ifndef U_HIDE_DRAFT_API

    Derived displayOptions(const DisplayOptions &displayOptions) const &;

    Derived displayOptions(const DisplayOptions &displayOptions) &&;
#endif // U_HIDE_DRAFT_API

#ifndef U_HIDE_INTERNAL_API

    Derived unitDisplayCase(StringPiece unitDisplayCase) const &;

    Derived unitDisplayCase(StringPiece unitDisplayCase) &&;
#endif // U_HIDE_INTERNAL_API

#ifndef U_HIDE_INTERNAL_API

    Derived padding(const impl::Padder &padder) const &;

    Derived padding(const impl::Padder &padder) &&;

    Derived threshold(int32_t threshold) const &;

    Derived threshold(int32_t threshold) &&;

    Derived macros(const impl::MacroProps& macros) const &;

    Derived macros(const impl::MacroProps& macros) &&;

    Derived macros(impl::MacroProps&& macros) const &;

    Derived macros(impl::MacroProps&& macros) &&;

#endif  /* U_HIDE_INTERNAL_API */

    UnicodeString toSkeleton(UErrorCode& status) const;

    LocalPointer<Derived> clone() const &;

    LocalPointer<Derived> clone() &&;

    UBool copyErrorTo(UErrorCode &outErrorCode) const {
        if (U_FAILURE(outErrorCode)) {
            // Do not overwrite the older error code
            return true;
        }
        fMacros.copyErrorTo(outErrorCode);
        return U_FAILURE(outErrorCode);
    }

    // NOTE: Uses default copy and move constructors.

  private:
    impl::MacroProps fMacros;

    // Don't construct me directly!  Use (Un)LocalizedNumberFormatter.
    NumberFormatterSettings() = default;

    friend class LocalizedNumberFormatter;
    friend class UnlocalizedNumberFormatter;

    // Give NumberRangeFormatter access to the MacroProps
    friend void impl::touchRangeLocales(impl::RangeMacroProps& macros);
    friend class impl::NumberRangeFormatterImpl;
};

// Explicit instantiations in source/i18n/number_fluent.cpp.
// (MSVC treats imports/exports of explicit instantiations differently.)
#ifndef _MSC_VER
extern template class NumberFormatterSettings<UnlocalizedNumberFormatter>;
extern template class NumberFormatterSettings<LocalizedNumberFormatter>;
#endif

class U_I18N_API UnlocalizedNumberFormatter
        : public NumberFormatterSettings<UnlocalizedNumberFormatter>, public UMemory {

  public:
    LocalizedNumberFormatter locale(const icu::Locale &locale) const &;

    LocalizedNumberFormatter locale(const icu::Locale &locale) &&;

    UnlocalizedNumberFormatter() = default;

    UnlocalizedNumberFormatter(const UnlocalizedNumberFormatter &other);

    UnlocalizedNumberFormatter(UnlocalizedNumberFormatter&& src) noexcept;

    UnlocalizedNumberFormatter& operator=(const UnlocalizedNumberFormatter& other);

    UnlocalizedNumberFormatter& operator=(UnlocalizedNumberFormatter&& src) noexcept;

  private:
    explicit UnlocalizedNumberFormatter(const NumberFormatterSettings<UnlocalizedNumberFormatter>& other);

    explicit UnlocalizedNumberFormatter(
            NumberFormatterSettings<UnlocalizedNumberFormatter>&& src) noexcept;

    // To give the fluent setters access to this class's constructor:
    friend class NumberFormatterSettings<UnlocalizedNumberFormatter>;

    // To give NumberFormatter::with() access to this class's constructor:
    friend class NumberFormatter;
};

class U_I18N_API LocalizedNumberFormatter
        : public NumberFormatterSettings<LocalizedNumberFormatter>, public UMemory {
  public:
    FormattedNumber formatInt(int64_t value, UErrorCode &status) const;

    FormattedNumber formatDouble(double value, UErrorCode &status) const;

    FormattedNumber formatDecimal(StringPiece value, UErrorCode& status) const;

#ifndef U_HIDE_INTERNAL_API

            
    const DecimalFormatSymbols* getDecimalFormatSymbols() const;
    
    FormattedNumber formatDecimalQuantity(const impl::DecimalQuantity& dq, UErrorCode& status) const;

    void getAffixImpl(bool isPrefix, bool isNegative, UnicodeString& result, UErrorCode& status) const;

    const impl::NumberFormatterImpl* getCompiled() const;

    int32_t getCallCount() const;

#endif  /* U_HIDE_INTERNAL_API */

    Format* toFormat(UErrorCode& status) const;

    LocalizedNumberFormatter() = default;

    LocalizedNumberFormatter(const LocalizedNumberFormatter &other);

    LocalizedNumberFormatter(LocalizedNumberFormatter&& src) noexcept;

    LocalizedNumberFormatter& operator=(const LocalizedNumberFormatter& other);

    LocalizedNumberFormatter& operator=(LocalizedNumberFormatter&& src) noexcept;

#ifndef U_HIDE_INTERNAL_API

    void formatImpl(impl::UFormattedNumberData *results, UErrorCode &status) const;

#endif  /* U_HIDE_INTERNAL_API */

    ~LocalizedNumberFormatter();

  private:
    // Note: fCompiled can't be a LocalPointer because impl::NumberFormatterImpl is defined in an internal
    // header, and LocalPointer needs the full class definition in order to delete the instance.
    const impl::NumberFormatterImpl* fCompiled {nullptr};
    char fUnsafeCallCount[8] {};  // internally cast to u_atomic_int32_t

    // Owned pointer to a DecimalFormatWarehouse, used when copying a LocalizedNumberFormatter
    // from a DecimalFormat.
    const impl::DecimalFormatWarehouse* fWarehouse {nullptr};

    explicit LocalizedNumberFormatter(const NumberFormatterSettings<LocalizedNumberFormatter>& other);

    explicit LocalizedNumberFormatter(NumberFormatterSettings<LocalizedNumberFormatter>&& src) noexcept;

    LocalizedNumberFormatter(const impl::MacroProps &macros, const Locale &locale);

    LocalizedNumberFormatter(impl::MacroProps &&macros, const Locale &locale);

    void resetCompiled();

    void lnfMoveHelper(LocalizedNumberFormatter&& src);

    void lnfCopyHelper(const LocalizedNumberFormatter& src, UErrorCode& status);

    bool computeCompiled(UErrorCode& status) const;

    // To give the fluent setters access to this class's constructor:
    friend class NumberFormatterSettings<UnlocalizedNumberFormatter>;
    friend class NumberFormatterSettings<LocalizedNumberFormatter>;

    // To give UnlocalizedNumberFormatter::locale() access to this class's constructor:
    friend class UnlocalizedNumberFormatter;
};

#if (U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN) && defined(_MSC_VER)
// Warning 4661.
#pragma warning(pop)
#endif

class U_I18N_API NumberFormatter final {
  public:
    static UnlocalizedNumberFormatter with();

    static LocalizedNumberFormatter withLocale(const Locale &locale);

    static UnlocalizedNumberFormatter forSkeleton(const UnicodeString& skeleton, UErrorCode& status);

    static UnlocalizedNumberFormatter forSkeleton(const UnicodeString& skeleton,
                                                  UParseError& perror, UErrorCode& status);

    NumberFormatter() = delete;
};

}  // namespace number
U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_FORMATTING */

#endif /* U_SHOW_CPLUSPLUS_API */

#endif // __NUMBERFORMATTER_H__