NumberConcept.hpp

/*
 * Copyright 2017-2024 Apple Inc. All rights reserved.
 */
#pragma once
 
#include <inflection/dialog/fwd.hpp>
#include <inflection/dialog/SpeakableConcept.hpp>
#include <inflection/util/fwd.hpp>
#include <inflection/util/ULocale.hpp>
#include <icu4cxx/fwd.hpp>
#include <unicode/unum.h>
#include <string>
 
class INFLECTION_CLASS_API inflection::dialog::NumberConcept
    : public virtual SpeakableConcept
{
public:
    typedef ::inflection::dialog::SpeakableConcept super;
 
private:
    struct Number {
        union {
            int64_t int64Val;
            double doubleVal;
        } value;
        enum {
            INT64,
            DOUBLE
        } type;
    };
 
private:
    Number value {  };
    ::inflection::util::ULocale language;
    ::inflection::util::ULocale regionLocale;
    int32_t maximumFractionDigits { -1 };
    int32_t minimumFractionDigits { -1 };
    int32_t maximumIntegerDigits { -1 };
    int32_t minimumIntegerDigits { -1 };
    int32_t groupingUsed { -1 };
    int32_t roundingMode { -1 };
 
private:
    static int64_t longValue(const ::inflection::dialog::NumberConcept::Number& value);
    static double doubleValue(const ::inflection::dialog::NumberConcept::Number& value);
    void copySettings(const NumberConcept& original);
 
public:
    virtual NumberConcept* getAbsolute() const;
 
private:
//    ::com::ibm::icu::math::BigDecimal* toBigDecimal() const;
//    static ::inflection::dialog::NumberConcept::Number toSmallestPrimitiveType(const ::inflection::dialog::NumberConcept::Number& value);
//    Number getRoundedNumber() const;
 
public:
//    virtual NumberConcept* getRoundedValue() const;
 
private:
    NumberConcept* getMutableVersion() const;
 
public:
    virtual NumberConcept* minFractionDigits(int32_t min) const;
 
    virtual NumberConcept* maxFractionDigits(int32_t max) const;
 
    virtual NumberConcept* maxFractionDigitsAboveOne(int32_t given) const;
 
    virtual int32_t getMaximumFractionDigits() const;
 
    virtual NumberConcept* minIntegerDigits(int32_t min) const;
 
    virtual NumberConcept* maxIntegerDigits(int32_t max) const;
 
    virtual NumberConcept* grouping(bool grouping) const;
 
    virtual NumberConcept* roundUp() const;
 
    virtual NumberConcept* roundDown() const;
 
    virtual NumberConcept* roundHalfUp() const;
 
    virtual NumberConcept* roundHalfDown() const;
 
    virtual NumberConcept* roundCeiling() const;
 
    virtual NumberConcept* roundFloor() const;
 
    virtual bool getIsNegative() const;
 
private:
    static bool hasFraction(const Number& value);
 
public:
    virtual bool hasFraction() const;
 
private:
    NumberConcept* round(int32_t roundMode) const;
 
public:
    virtual const ::inflection::util::ULocale& getLanguage() const;
 
    virtual const ::inflection::util::ULocale& getRegionLocale() const;
 
    ::std::u16string toString() const override;
 
    SpeakableString* toSpeakableString() const override;
 
    virtual ::std::u16string getAsWords() const;
 
    virtual ::std::u16string asWords(const ::std::u16string& variant) const;
 
    virtual SpeakableString getAsSpokenWords() const;
 
    virtual SpeakableString asSpokenWords(const ::std::u16string& variant) const;
 
    virtual SpeakableString getAsDigits() const;
 
    virtual ::std::u16string getAsOrdinalDigits() const;
 
    virtual ::std::u16string asDigits(const ::std::u16string& variant) const;
 
private:
    ::icu4cxx::NumberFormat createSimpleNumberFormat(const ::inflection::util::ULocale& locale) const;
    ::icu4cxx::NumberFormat* configure(::icu4cxx::NumberFormat* numberFormat) const;
    ::std::u16string format(UNumberFormatStyle type, const ::std::u16string& variant) const;
    ::icu4cxx::NumberFormat createRuleBasedNumberFormat(UNumberFormatStyle type) const;
    bool isIntegral() const;
    ::std::u16string format(const ::icu4cxx::NumberFormat& rbnf) const;
    static ::std::u16string postProcess(const ::std::u16string& formattedValue);
 
public:
    bool operator==(const NumberConcept& o) const;
 
    std::size_t operator()(const NumberConcept& o) const noexcept;
 
    std::partial_ordering operator<=>(const NumberConcept& o) const;
 
    int64_t longValue() const;
 
    double doubleValue() const;
 
    NumberConcept(int64_t value, const ::inflection::util::ULocale& language, const ::inflection::util::ULocale& regionLocale);
    NumberConcept(double value, const ::inflection::util::ULocale& language, const ::inflection::util::ULocale& regionLocale);
    NumberConcept(const NumberConcept& original);
 
    ~NumberConcept() override;
private:
    NumberConcept& operator=(const NumberConcept&) = delete;
};