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 {
 
    // Formattable
    // ----------

    class U_I18N_API_CLASS FormattableObject : public UObject {
    public:
        U_I18N_API virtual const UnicodeString& tag() const = 0;
        U_I18N_API 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) {
                    auto result = std::get_if<const FormattableObject*>(&contents);
                    // It would be better to U_ASSERT(result != nullptr) here, but
                    // this is a public header file so we can't include uassert.h
                    if (result != nullptr) {
                        return *result;
                    }
                }
                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 FunctionValue;
class U_I18N_API_CLASS ResolvedFunctionOption : public UObject {
  private:
    friend class FunctionOptions;
 
    /* const */ UnicodeString name;
    // owned by the global environment
    const FunctionValue* value;
    // True if this option is the product of merging two
    // option maps together, and this option came from the
    // first argument (the "older" options map).
    bool thisWasMerged = false;
 
  public:
      U_I18N_API const UnicodeString& getName() const { return name; }
      U_I18N_API const FunctionValue& getValue() const { return *value; }
      U_I18N_API bool wasMerged() const { return thisWasMerged; }
      U_I18N_API ResolvedFunctionOption(const UnicodeString& n, const FunctionValue& f, bool b);
      U_I18N_API ResolvedFunctionOption() {}
      U_I18N_API ResolvedFunctionOption(ResolvedFunctionOption&&);
      U_I18N_API ResolvedFunctionOption& operator=(ResolvedFunctionOption&& other) = default;
      U_I18N_API ResolvedFunctionOption& operator=(const ResolvedFunctionOption& other) = default;
      U_I18N_API ResolvedFunctionOption(const ResolvedFunctionOption&) = default;
      U_I18N_API virtual ~ResolvedFunctionOption();
}; // class ResolvedFunctionOption
#endif

using FunctionOptionsMap = std::map<UnicodeString, const message2::FunctionValue*>;

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

     FunctionOptions mergeOptions(const FunctionOptions& other, UErrorCode&) const;
     FunctionOptions() { options = nullptr; }
     virtual ~FunctionOptions();
     friend inline void swap(FunctionOptions& f1, FunctionOptions& f2) noexcept {
        using std::swap;
 
        if (f1.bogus || f2.bogus) {
            f1.bogus = f2.bogus = true;
            return;
        }
        swap(f1.options, f2.options);
        swap(f1.functionOptionsLen, f2.functionOptionsLen);
    }

     FunctionOptions& operator=(FunctionOptions) noexcept;
     FunctionOptions(const FunctionOptions&);
 private:
    friend class MessageFormatter;
    friend class StandardFunctions;
 
    explicit FunctionOptions(UVector&&, UErrorCode&);
 
    const ResolvedFunctionOption* getResolvedFunctionOptions(int32_t& len) const;
    const FunctionValue* getFunctionOption(const std::u16string_view, UErrorCode&) const;
    // Returns empty string if option doesn't exist
    UnicodeString getStringFunctionOption(const std::u16string_view) const;
    UBool wasSetFromLiteral(const std::u16string_view) const;
    // Sets error code if option doesn't exist
    UnicodeString getStringFunctionOption(const std::u16string_view, UErrorCode&) const;
    int32_t optionsCount() const { return functionOptionsLen; }
 
    bool bogus = false; // Used in case a copy fails
    // 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

    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