messageformat2_formattable.h

// © 2024 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
 
#include "unicode/utypes.h"
 
#ifndef MESSAGEFORMAT2_FORMATTABLE_H
#define MESSAGEFORMAT2_FORMATTABLE_H
 
#if U_SHOW_CPLUSPLUS_API
 
#if !UCONFIG_NO_NORMALIZATION
 
#if !UCONFIG_NO_FORMATTING
 
#if !UCONFIG_NO_MF2
 
#include "unicode/chariter.h"
#include "unicode/numberformatter.h"
#include "unicode/messageformat2_data_model_names.h"
#include "unicode/smpdtfmt.h"
 
#ifndef U_HIDE_DEPRECATED_API
 
#include <map>
#include <variant>
 
U_NAMESPACE_BEGIN
 
class Hashtable;
class UVector;
 
namespace message2 {
 
    class Formatter;
    class MessageContext;
    class Selector;
 
    // Formattable
    // ----------

    class U_I18N_API FormattableObject : public UObject {
    public:
        virtual const UnicodeString& tag() const = 0;
        virtual ~FormattableObject();
    }; // class FormattableObject

    struct U_I18N_API DateInfo {
        UDate date;
        UnicodeString zoneId;
    };

    class U_I18N_API_CLASS Formattable : public UObject {
    public:

        U_I18N_API UFormattableType getType() const;

        U_I18N_API double getDouble(UErrorCode& status) const {
            if (U_SUCCESS(status)) {
                if (isDecimal() && getType() == UFMT_DOUBLE) {
                    return (std::get_if<icu::Formattable>(&contents))->getDouble();
                }
                if (std::holds_alternative<double>(contents)) {
                    return *(std::get_if<double>(&contents));
                }
                status = U_ILLEGAL_ARGUMENT_ERROR;
            }
            return 0;
        }

        U_I18N_API int32_t getLong(UErrorCode& status) const {
            if (U_SUCCESS(status)) {
                if (isDecimal() && getType() == UFMT_LONG) {
                    return std::get_if<icu::Formattable>(&contents)->getLong();
                }
                if (std::holds_alternative<int64_t>(contents)) {
                    return static_cast<int32_t>(*(std::get_if<int64_t>(&contents)));
                }
                status = U_ILLEGAL_ARGUMENT_ERROR;
            }
            return 0;
        }

        U_I18N_API int64_t getInt64Value(UErrorCode& status) const {
            if (U_SUCCESS(status)) {
                if (isDecimal() && getType() == UFMT_INT64) {
                    return std::get_if<icu::Formattable>(&contents)->getInt64();
                }
                if (std::holds_alternative<int64_t>(contents)) {
                    return *(std::get_if<int64_t>(&contents));
                }
                status = U_ILLEGAL_ARGUMENT_ERROR;
            }
            return 0;
        }

        U_I18N_API int64_t getInt64(UErrorCode& status) const;
        U_I18N_API const UnicodeString& getString(UErrorCode& status) const {
            if (U_SUCCESS(status)) {
                if (std::holds_alternative<UnicodeString>(contents)) {
                    return *std::get_if<UnicodeString>(&contents);
                }
                status = U_ILLEGAL_ARGUMENT_ERROR;
            }
            return bogusString;
        }

        U_I18N_API const DateInfo* getDate(UErrorCode& status) const {
            if (U_SUCCESS(status)) {
                if (isDate()) {
                    return std::get_if<DateInfo>(&contents);
                }
                status = U_ILLEGAL_ARGUMENT_ERROR;
            }
            return nullptr;
        }

        U_I18N_API UBool isNumeric() const { return (getType() == UFMT_DOUBLE || getType() == UFMT_LONG || getType() == UFMT_INT64); }

        U_I18N_API const Formattable* getArray(int32_t& count, UErrorCode& status) const;

        U_I18N_API const FormattableObject* getObject(UErrorCode& status) const {
            if (U_SUCCESS(status)) {
                // Can't return a reference since FormattableObject
                // is an abstract class
                if (getType() == UFMT_OBJECT) {
                    return *std::get_if<const FormattableObject*>(&contents);
                    // TODO: should assert that if type is object, object is non-null
                }
                status = U_ILLEGAL_ARGUMENT_ERROR;
            }
            return nullptr;
        }

        U_I18N_API friend inline void swap(Formattable& f1, Formattable& f2) noexcept {
            using std::swap;
 
            swap(f1.contents, f2.contents);
        }

        U_I18N_API Formattable(const Formattable&);
        U_I18N_API Formattable& operator=(Formattable) noexcept;
        U_I18N_API Formattable() : contents(0.0) {}
        U_I18N_API Formattable(const UnicodeString& s) : contents(s) {}
        U_I18N_API Formattable(double d) : contents(d) {}
        U_I18N_API Formattable(int64_t i) : contents(i) {}
        U_I18N_API Formattable(DateInfo&& d) : contents(std::move(d)) {}
        U_I18N_API static Formattable forDecimal(std::string_view number, UErrorCode& status);
        U_I18N_API Formattable(const Formattable* arr, int32_t len) : contents(std::pair(arr, len)) {}
        U_I18N_API Formattable(const FormattableObject* obj) : contents(obj) {}
        U_I18N_API virtual ~Formattable();
        U_I18N_API icu::Formattable asICUFormattable(UErrorCode& status) const;
    private:
 
        std::variant<double,
                     int64_t,
                     UnicodeString,
                     icu::Formattable, // represents a Decimal
                     DateInfo,
                     const FormattableObject*,
                     std::pair<const Formattable*, int32_t>> contents;
        UnicodeString bogusString; // :((((
 
        UBool isDecimal() const {
            return std::holds_alternative<icu::Formattable>(contents);
        }
        UBool isDate() const {
            return std::holds_alternative<DateInfo>(contents);
        }
    }; // class Formattable

#ifndef U_IN_DOXYGEN
class U_I18N_API_CLASS ResolvedFunctionOption : public UObject {
  private:
 
    /* const */ UnicodeString name;
    /* const */ Formattable value;
    // True iff this option was represented in the syntax by a literal value.
    // This is necessary in order to implement the spec for the `select` option
    // of `:number` and `:integer`.
    /* const */ bool sourceIsLiteral;
 
  public:
      U_I18N_API const UnicodeString& getName() const { return name; }
      U_I18N_API const Formattable& getValue() const { return value; }
      U_I18N_API bool isLiteral() const { return sourceIsLiteral; }
      U_I18N_API ResolvedFunctionOption(const UnicodeString& n, const Formattable& f, bool s)
          : name(n), value(f), sourceIsLiteral(s) {}
      U_I18N_API ResolvedFunctionOption() {}
      U_I18N_API ResolvedFunctionOption(ResolvedFunctionOption&&);
      U_I18N_API ResolvedFunctionOption& operator=(ResolvedFunctionOption&& other) noexcept {
          name = std::move(other.name);
          value = std::move(other.value);
          sourceIsLiteral = other.sourceIsLiteral;
          return *this;
    }
    U_I18N_API virtual ~ResolvedFunctionOption();
}; // class ResolvedFunctionOption
#endif

using FunctionOptionsMap = std::map<UnicodeString, message2::Formattable>;

class U_I18N_API FunctionOptions : public UObject {
 public:
    FunctionOptionsMap getOptions() const {
        int32_t len;
        const ResolvedFunctionOption* resolvedOptions = getResolvedFunctionOptions(len);
        FunctionOptionsMap result;
        for (int32_t i = 0; i < len; i++) {
            const ResolvedFunctionOption& opt = resolvedOptions[i];
            result[opt.getName()] = opt.getValue();
        }
        return result;
    }

    FunctionOptions() { options = nullptr; }
    virtual ~FunctionOptions();
    FunctionOptions& operator=(FunctionOptions&&) noexcept;
    FunctionOptions(FunctionOptions&&);
    FunctionOptions& operator=(const FunctionOptions&) = delete;
 private:
    friend class InternalValue;
    friend class MessageFormatter;
    friend class StandardFunctions;
 
    explicit FunctionOptions(UVector&&, UErrorCode&);
 
    const ResolvedFunctionOption* getResolvedFunctionOptions(int32_t& len) const;
    UBool getFunctionOption(std::u16string_view, Formattable&) const;
    UBool wasSetFromLiteral(const UnicodeString&) const;
    // Returns empty string if option doesn't exist
    UnicodeString getStringFunctionOption(std::u16string_view) const;
    int32_t optionsCount() const { return functionOptionsLen; }
 
    // Named options passed to functions
    // This is not a Hashtable in order to make it possible for code in a public header file
    // to construct a std::map from it, on-the-fly. Otherwise, it would be impossible to put
    // that code in the header because it would have to call internal Hashtable methods.
    ResolvedFunctionOption* options;
    int32_t functionOptionsLen = 0;

    FunctionOptions mergeOptions(FunctionOptions&& other, UErrorCode&);
}; // class FunctionOptions

    class U_I18N_API FormattedValue : public UObject {
    public:
        explicit FormattedValue(const UnicodeString&);
        explicit FormattedValue(number::FormattedNumber&&);
        FormattedValue() : type(kString) {}
        bool isString() const { return type == kString; }
        bool isNumber() const { return type == kNumber; }
        const UnicodeString& getString() const { return stringOutput; }
        const number::FormattedNumber& getNumber() const { return numberOutput; }
        FormattedValue& operator=(FormattedValue&&) noexcept;
        FormattedValue(FormattedValue&& other) { *this = std::move(other); }
        virtual ~FormattedValue();
    private:
        enum Type {
            kString,
            kNumber
        };
        Type type;
        UnicodeString stringOutput;
        number::FormattedNumber numberOutput;
    }; // class FormattedValue

    class U_I18N_API_CLASS FormattedPlaceholder : public UObject {
    public:
        U_I18N_API explicit FormattedPlaceholder(const UnicodeString& s) : fallback(s), type(kFallback) {}
        U_I18N_API FormattedPlaceholder(const FormattedPlaceholder& input, FormattedValue&& output)
            : fallback(input.fallback), source(input.source),
            formatted(std::move(output)), previousOptions(FunctionOptions()), type(kEvaluated) {}

        U_I18N_API FormattedPlaceholder(const FormattedPlaceholder& input, FunctionOptions&& opts, FormattedValue&& output)
            : fallback(input.fallback), source(input.source),
            formatted(std::move(output)), previousOptions(std::move(opts)), type(kEvaluated) {}

        U_I18N_API FormattedPlaceholder(const Formattable& input, const UnicodeString& fb)
            : fallback(fb), source(input), type(kUnevaluated) {}

        U_I18N_API FormattedPlaceholder() : type(kNull) {}
        U_I18N_API const message2::Formattable& asFormattable() const;
        U_I18N_API bool isFallback() const { return type == kFallback; }
        U_I18N_API bool isNullOperand() const { return type == kNull; }
        U_I18N_API bool isEvaluated() const { return (type == kEvaluated); }
        U_I18N_API bool canFormat() const { return !(isFallback() || isNullOperand()); }
        U_I18N_API const UnicodeString& getFallback() const { return fallback; }
        U_I18N_API const FunctionOptions& options() const { return previousOptions; }
        U_I18N_API const FormattedValue& output() const { return formatted; }
        U_I18N_API FormattedPlaceholder& operator=(FormattedPlaceholder&&) noexcept;
        U_I18N_API FormattedPlaceholder(FormattedPlaceholder&& other) { *this = std::move(other); }
        U_I18N_API UnicodeString formatToString(const Locale& locale,
                                     UErrorCode& status) const;
 
    private:
        friend class MessageFormatter;
 
        enum Type {
            kFallback,    // Represents the result of formatting that encountered an error
            kNull,        // Represents the absence of both an output and an input (not necessarily an error)
            kUnevaluated, // `source` should be valid, but there's no result yet
            kEvaluated,   // `formatted` exists
        };
        UnicodeString fallback;
        Formattable source;
        FormattedValue formatted;
        FunctionOptions previousOptions; // Ignored unless type is kEvaluated
        Type type;
    }; // class FormattedPlaceholder

    class U_I18N_API FormattedMessage : public icu::FormattedValue {
    public:
        FormattedMessage(UErrorCode& status) {
            if (U_SUCCESS(status)) {
                status = U_UNSUPPORTED_ERROR;
            }
        }

        int32_t length(UErrorCode& status) const {
            if (U_SUCCESS(status)) {
                status = U_UNSUPPORTED_ERROR;
            }
            return -1;
        }

        char16_t charAt(int32_t index, UErrorCode& status) const {
            (void) index;
            if (U_SUCCESS(status)) {
                status = U_UNSUPPORTED_ERROR;
            }
            return 0;
        }

        StringPiece subSequence(int32_t start, int32_t end, UErrorCode& status) const {
            (void) start;
            (void) end;
            if (U_SUCCESS(status)) {
                status = U_UNSUPPORTED_ERROR;
            }
            return "";
        }

        UnicodeString toString(UErrorCode& status) const override {
            if (U_SUCCESS(status)) {
                status = U_UNSUPPORTED_ERROR;
            }
            return {};
        }

        UnicodeString toTempString(UErrorCode& status) const override {
            if (U_SUCCESS(status)) {
                status = U_UNSUPPORTED_ERROR;
            }
            return {};
        }

        Appendable& appendTo(Appendable& appendable, UErrorCode& status) const override {
            if (U_SUCCESS(status)) {
                status = U_UNSUPPORTED_ERROR;
            }
            return appendable;
        }

        UBool nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode& status) const override {
            (void) cfpos;
            if (U_SUCCESS(status)) {
                status = U_UNSUPPORTED_ERROR;
            }
            return false;
        }

        CharacterIterator* toCharacterIterator(UErrorCode& status) {
            if (U_SUCCESS(status)) {
                status = U_UNSUPPORTED_ERROR;
            }
            return nullptr;
        }

        virtual ~FormattedMessage();
    }; // class FormattedMessage
 
} // namespace message2
 
U_NAMESPACE_END
 
#endif // U_HIDE_DEPRECATED_API
 
#endif /* #if !UCONFIG_NO_MF2 */
 
#endif /* #if !UCONFIG_NO_FORMATTING */
 
#endif /* #if !UCONFIG_NO_NORMALIZATION */
 
#endif /* U_SHOW_CPLUSPLUS_API */
 
#endif // MESSAGEFORMAT2_FORMATTABLE_H
 
// eof