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_FORMATTING
 
#if !UCONFIG_NO_MF2
 
#include "unicode/chariter.h"
#include "unicode/numberformatter.h"
#include "unicode/messageformat2_data_model_names.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
 
    class Formattable;
} // namespace message2
 
U_NAMESPACE_END
 
// Export an explicit template instantiation of the std::variant that is used
// to represent the message2::Formattable class.
// (When building DLLs for Windows this is required.)
// (See measunit_impl.h, datefmt.h, collationiterator.h, erarules.h and others
// for similar examples.)
#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
#if defined(_MSC_VER)
// Ignore warning 4661 as LocalPointerBase does not use operator== or operator!=
#pragma warning(push)
#pragma warning(disable: 4661)
#endif
#if defined(_MSC_VER)
template class U_I18N_API std::_Variant_storage_<false,
  double,
  int64_t,
  icu::UnicodeString,
  icu::Formattable,
  const icu::message2::FormattableObject *,
  std::pair<const icu::message2::Formattable *,int32_t>>;
#endif
typedef std::pair<const icu::message2::Formattable*, int32_t> P;
template class U_I18N_API std::variant<double,
                                       int64_t,
                                       icu::UnicodeString,
                                       icu::Formattable,
                                       const icu::message2::FormattableObject*,
                                       P>;
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
#endif
 
U_NAMESPACE_BEGIN
 
namespace message2 {
    class U_I18N_API Formattable : public UObject {
    public:
 
        UFormattableType getType() const;
 
        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;
        }
 
        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;
        }
 
        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;
        }
 
        int64_t         getInt64(UErrorCode& status) const;
        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;
        }
 
        UDate getDate(UErrorCode& status) const {
            if (U_SUCCESS(status)) {
                if (isDate()) {
                    return *std::get_if<double>(&contents);
                }
                status = U_ILLEGAL_ARGUMENT_ERROR;
            }
            return 0;
        }
 
        UBool isNumeric() const { return (getType() == UFMT_DOUBLE || getType() == UFMT_LONG || getType() == UFMT_INT64); }
 
        const Formattable* getArray(int32_t& count, UErrorCode& status) const;
 
        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;
        }
        friend inline void swap(Formattable& f1, Formattable& f2) noexcept {
            using std::swap;
 
            swap(f1.contents, f2.contents);
            swap(f1.holdsDate, f2.holdsDate);
        }
        Formattable(const Formattable&);
        Formattable& operator=(Formattable) noexcept;
        Formattable() : contents(0.0) {}
        Formattable(const UnicodeString& s) : contents(s) {}
        Formattable(double d) : contents(d) {}
        Formattable(int64_t i) : contents(i) {}
        static Formattable forDate(UDate d) {
            Formattable f;
            f.contents = d;
            f.holdsDate = true;
            return f;
        }
        static Formattable forDecimal(std::string_view number, UErrorCode& status);
        Formattable(const Formattable* arr, int32_t len) : contents(std::pair(arr, len)) {}
        Formattable(const FormattableObject* obj) : contents(obj) {}
        virtual ~Formattable();
        icu::Formattable asICUFormattable(UErrorCode& status) const;
    private:
 
        std::variant<double,
                     int64_t,
                     UnicodeString,
                     icu::Formattable, // represents a Decimal
                     const FormattableObject*,
                     std::pair<const Formattable*, int32_t>> contents;
        bool holdsDate = false; // otherwise, we get type errors about UDate being a duplicate type
        UnicodeString bogusString; // :((((
 
        UBool isDecimal() const {
            return std::holds_alternative<icu::Formattable>(contents);
        }
        UBool isDate() const {
            return std::holds_alternative<double>(contents) && holdsDate;
        }
    }; // class Formattable
 
#ifndef U_IN_DOXYGEN
class U_I18N_API ResolvedFunctionOption : public UObject {
  private:
 
    /* const */ UnicodeString name;
    /* const */ Formattable value;
 
  public:
      const UnicodeString& getName() const { return name; }
      const Formattable& getValue() const { return value; }
      ResolvedFunctionOption(const UnicodeString& n, const Formattable& f) : name(n), value(f) {}
      ResolvedFunctionOption() {}
      ResolvedFunctionOption(ResolvedFunctionOption&&);
      ResolvedFunctionOption& operator=(ResolvedFunctionOption&& other) noexcept {
          name = std::move(other.name);
          value = std::move(other.value);
          return *this;
    }
    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 MessageFormatter;
    friend class StandardFunctions;
 
    explicit FunctionOptions(UVector&&, UErrorCode&);
 
    const ResolvedFunctionOption* getResolvedFunctionOptions(int32_t& len) const;
    UBool getFunctionOption(const UnicodeString&, Formattable&) const;
    // Returns empty string if option doesn't exist
    UnicodeString getStringFunctionOption(const UnicodeString&) 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;
}; // class FunctionOptions
 
 
    // TODO doc comments
    // Encapsulates either a formatted string or formatted number;
    // more output types could be added in the future.
 
    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 FormattedPlaceholder : public UObject {
    public:
        explicit FormattedPlaceholder(const UnicodeString& s) : fallback(s), type(kFallback) {}
        FormattedPlaceholder(const FormattedPlaceholder& input, FormattedValue&& output)
            : fallback(input.fallback), source(input.source),
            formatted(std::move(output)), previousOptions(FunctionOptions()), type(kEvaluated) {}
        FormattedPlaceholder(const FormattedPlaceholder& input, FunctionOptions&& opts, FormattedValue&& output)
            : fallback(input.fallback), source(input.source),
            formatted(std::move(output)), previousOptions(std::move(opts)), type(kEvaluated) {}
        FormattedPlaceholder(const Formattable& input, const UnicodeString& fb)
            : fallback(fb), source(input), type(kUnevaluated) {}
        FormattedPlaceholder() : type(kNull) {}
        const message2::Formattable& asFormattable() const;
        bool isFallback() const { return type == kFallback; }
        bool isNullOperand() const { return type == kNull; }
        bool isEvaluated() const { return (type == kEvaluated); }
        bool canFormat() const { return !(isFallback() || isNullOperand()); }
        const UnicodeString& getFallback() const { return fallback; }
        const FunctionOptions& options() const { return previousOptions; }
 
        const FormattedValue& output() const { return formatted; }
        FormattedPlaceholder& operator=(FormattedPlaceholder&&) noexcept;
        FormattedPlaceholder(FormattedPlaceholder&& other) { *this = std::move(other); }
        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 /* U_SHOW_CPLUSPLUS_API */
 
#endif // MESSAGEFORMAT2_FORMATTABLE_H
 
// eof