messageformat2_data_model.h

// © 2024 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
 
#include "unicode/utypes.h"
 
#ifndef MESSAGEFORMAT_DATA_MODEL_H
#define MESSAGEFORMAT_DATA_MODEL_H
 
#if U_SHOW_CPLUSPLUS_API
 
#if !UCONFIG_NO_NORMALIZATION
 
#if !UCONFIG_NO_FORMATTING
 
#if !UCONFIG_NO_MF2
 
#include "unicode/localpointer.h"
#include "unicode/messageformat2_data_model_names.h"
 
#ifndef U_HIDE_DEPRECATED_API
 
#include <algorithm>
#include <cstddef>
#include <iterator>
#include <optional>
#include <variant>
#include <vector>
 
U_NAMESPACE_BEGIN
 
class UVector;
 
// Helpers
 
// Note: this _must_ be declared `inline` or else gcc will generate code
// for its instantiations, which needs to be avoided because it returns
// a std::vector
template<typename T>
static inline std::vector<T> toStdVector(const T* arr, int32_t len) {
    std::vector<T> result;
    for (int32_t i = 0; i < len; i++) {
        result.push_back(arr[i]);
    }
    return result;
}
 
#if defined(U_REAL_MSVC)
#pragma warning(push)
// Ignore warning 4251 as these templates are instantiated later in this file,
// after the classes used to instantiate them have been defined.
#pragma warning(disable: 4251)
#endif
 
namespace message2 {
    class Checker;
    class MessageFormatter;
    class Parser;
    class Serializer;
 
 
  namespace data_model {
        class Binding;
        class Literal;
        class Operator;
        class MFDataModel;

        class U_I18N_API Literal : public UObject {
        public:
            UnicodeString quoted() const;
            const UnicodeString& unquoted() const;
            UBool isQuoted() const { return thisIsQuoted; }
            Literal(UBool q, const UnicodeString& s) : thisIsQuoted(q), contents(s) {}
            Literal(const Literal& other) : thisIsQuoted(other.thisIsQuoted), contents(other.contents) {}
            friend inline void swap(Literal& l1, Literal& l2) noexcept {
                using std::swap;
 
                swap(l1.thisIsQuoted, l2.thisIsQuoted);
                swap(l1.contents, l2.contents);
            }

            Literal& operator=(Literal) noexcept;
            Literal() = default;
            bool operator<(const Literal& other) const;
            bool operator==(const Literal& other) const;
            virtual ~Literal();
 
        private:
            /* const */ bool thisIsQuoted = false;
            /* const */ UnicodeString contents;
        };

        class U_I18N_API_CLASS Operand : public UObject {
        public:
            U_I18N_API UBool isVariable() const;
            U_I18N_API UBool isLiteral() const;
            U_I18N_API virtual UBool isNull() const;
            U_I18N_API const UnicodeString& asVariable() const;
            U_I18N_API const Literal& asLiteral() const;
            U_I18N_API Operand() : contents(std::nullopt) {}
            U_I18N_API explicit Operand(const UnicodeString& v) : contents(VariableName(v)) {}
            U_I18N_API explicit Operand(const Literal& l) : contents(l) {}
            U_I18N_API friend inline void swap(Operand& o1, Operand& o2) noexcept {
                using std::swap;
                (void) o1;
                (void) o2;
                swap(o1.contents, o2.contents);
            }

            U_I18N_API virtual Operand& operator=(Operand) noexcept;
            U_I18N_API Operand(const Operand&);
            U_I18N_API virtual ~Operand();
        private:
            std::optional<std::variant<VariableName, Literal>> contents;
        }; // class Operand

        class U_I18N_API_CLASS Key : public UObject {
        public:
            U_I18N_API UBool isWildcard() const { return !contents.has_value(); }
            U_I18N_API const Literal& asLiteral() const;
            U_I18N_API Key(const Key& other) : contents(other.contents) {}
            U_I18N_API Key() : contents(std::nullopt) {}
            U_I18N_API explicit Key(const Literal& lit) : contents(lit) {}
            U_I18N_API friend inline void swap(Key& k1, Key& k2) noexcept {
                using std::swap;
 
                swap(k1.contents, k2.contents);
            }

            U_I18N_API Key& operator=(Key) noexcept;
            U_I18N_API bool operator<(const Key& other) const;
            U_I18N_API bool operator==(const Key& other) const;
            U_I18N_API virtual ~Key();
        private:
            /* const */ std::optional<Literal> contents;
        }; // class Key

        class U_I18N_API_CLASS SelectorKeys : public UObject {
        public:
            U_I18N_API std::vector<Key> getKeys() const {
                return toStdVector<Key>(keys.getAlias(), len);
            }

            class U_I18N_API Builder : public UMemory {
            private:
                friend class SelectorKeys;
                UVector* keys; // This is a raw pointer and not a LocalPointer<UVector> to avoid undefined behavior warnings,
                               // since UVector is forward-declared
                               // The vector owns its elements
            public:
                Builder& add(Key&& key, UErrorCode& status) noexcept;
                SelectorKeys build(UErrorCode& status) const;
                Builder(UErrorCode& status);
                virtual ~Builder();
                Builder(const Builder&) = delete;
                Builder& operator=(const Builder&) = delete;
                Builder(Builder&&) = delete;
                Builder& operator=(Builder&&) = delete;
            }; // class SelectorKeys::Builder

            U_I18N_API bool operator<(const SelectorKeys& other) const;
            U_I18N_API SelectorKeys() : len(0) {}
            U_I18N_API friend inline void swap(SelectorKeys& s1, SelectorKeys& s2) noexcept {
                using std::swap;
 
                swap(s1.len, s2.len);
                swap(s1.keys, s2.keys);
            }

            U_I18N_API SelectorKeys(const SelectorKeys& other);
            U_I18N_API SelectorKeys& operator=(SelectorKeys other) noexcept;
            U_I18N_API virtual ~SelectorKeys();
        private:
            friend class Builder;
            friend class message2::Checker;
            friend class message2::MessageFormatter;
            friend class message2::Serializer;
 
            /* const */ LocalArray<Key> keys;
            /* const */ int32_t len;
 
            const Key* getKeysInternal() const;
            SelectorKeys(const UVector& ks, UErrorCode& status);
        }; // class SelectorKeys
 
        class Operator;

        class U_I18N_API Option : public UObject {
        public:
            const Operand& getValue() const { return rand; }
            const UnicodeString& getName() const { return name; }
            Option(const UnicodeString& n, Operand&& r) : name(n), rand(std::move(r)) {}
            Option() {}
            friend inline void swap(Option& o1, Option& o2) noexcept {
                using std::swap;
 
                swap(o1.name, o2.name);
                swap(o1.rand, o2.rand);
            }

            Option(const Option& other);
            Option& operator=(Option other) noexcept;
            virtual ~Option();
        private:
            /* const */ UnicodeString name;
            /* const */ Operand rand;
        }; // class Option
 
        // Internal only
        #ifndef U_IN_DOXYGEN
        // Options
        // This is a wrapper class around a vector of options that provides lookup operations
        class U_I18N_API_CLASS OptionMap : public UObject {
        public:
            U_I18N_API int32_t size() const;
            // Needs to take an error code b/c an earlier copy might have failed
            U_I18N_API const Option& getOption(int32_t, UErrorCode&) const;
            U_I18N_API friend inline void swap(OptionMap& m1, OptionMap& m2) noexcept {
                using std::swap;
 
                swap(m1.bogus, m2.bogus);
                swap(m1.options, m2.options);
                swap(m1.len, m2.len);
            }
            U_I18N_API OptionMap() : len(0) {}
            U_I18N_API OptionMap(const OptionMap&);
            U_I18N_API OptionMap& operator=(OptionMap);
            U_I18N_API std::vector<Option> getOptions() const {
                return toStdVector<Option>(options.getAlias(), len);
            }
            U_I18N_API OptionMap(const UVector&, UErrorCode&);
            U_I18N_API OptionMap(Option*, int32_t);
            U_I18N_API virtual ~OptionMap();
 
            class U_I18N_API Builder : public UObject {
                private:
                    UVector* options;
                    bool checkDuplicates = true;
                public:
                    Builder& add(Option&& opt, UErrorCode&);
                    Builder(UErrorCode&);
                    static Builder attributes(UErrorCode&);
                    // As this class is private, build() is destructive
                    OptionMap build(UErrorCode&);
                    friend inline void swap(Builder& m1, Builder& m2) noexcept {
                      using std::swap;
 
                      swap(m1.options, m2.options);
                      swap(m1.checkDuplicates, m2.checkDuplicates);
                    }
                    Builder(Builder&&);
                    Builder(const Builder&) = delete;
                    Builder& operator=(Builder) noexcept;
                    virtual ~Builder();
            }; // class OptionMap::Builder
        private:
            friend class message2::MessageFormatter;
            friend class message2::Serializer;
 
            bool bogus = false;
            LocalArray<Option> options;
            int32_t len;
        }; // class OptionMap
        #endif

        class U_I18N_API Operator : public UObject {
        public:
            const FunctionName& getFunctionName() const;
            std::vector<Option> getOptions() const {
                return options.getOptions();
            }

            class U_I18N_API Builder : public UMemory {
            private:
                friend class Operator;
                FunctionName functionName;
                OptionMap::Builder options;
            public:
                Builder& setFunctionName(FunctionName&& func);
                Builder& addOption(const UnicodeString &key, Operand&& value, UErrorCode& status) noexcept;
                Operator build(UErrorCode& status);
                Builder(UErrorCode& status);
                virtual ~Builder();
                Builder(const Builder&) = delete;
                Builder& operator=(const Builder&) = delete;
                Builder(Builder&&) = delete;
                Builder& operator=(Builder&&) = delete;
            }; // class Operator::Builder

            Operator(const Operator& other) noexcept;
            friend inline void swap(Operator& o1, Operator& o2) noexcept {
                using std::swap;
 
                swap(o1.name, o2.name);
                swap(o1.options, o2.options);
            }

            Operator& operator=(Operator) noexcept;
            Operator() {}
            virtual ~Operator();
        private:
            friend class Binding;
            friend class Builder;
            friend class message2::Checker;
            friend class message2::MessageFormatter;
            friend class message2::Serializer;
 
            // Function call constructor
            Operator(const FunctionName& f, const UVector& options, UErrorCode&);
 
            const OptionMap& getOptionsInternal() const;
            Operator(const FunctionName&, const OptionMap&);
 
            /* const */ FunctionName name;
            /* const */ OptionMap options;
        }; // class Operator
 
      // Internal only
      typedef enum UMarkupType {
          UMARKUP_OPEN = 0,
          UMARKUP_CLOSE,
          UMARKUP_STANDALONE,
          UMARKUP_COUNT
      } UMarkupType;

        class U_I18N_API Markup : public UObject {
        public:
            UBool isOpen() const { return (type == UMARKUP_OPEN); }
            UBool isClose() const { return (type == UMARKUP_CLOSE); }
            UBool isStandalone() const { return (type == UMARKUP_STANDALONE); }
            const UnicodeString& getName() const { return name; }
            std::vector<Option> getOptions() const { return options.getOptions(); }
            std::vector<Option> getAttributes() const { return attributes.getOptions(); }
            Markup() {}
            virtual ~Markup();
            class U_I18N_API Builder : public UMemory {
            private:
                friend class Markup;
 
                UnicodeString name;
                OptionMap::Builder options;
                OptionMap::Builder attributes;
                UMarkupType type = UMARKUP_COUNT;
            public:
                Builder& setName(const UnicodeString& n) { name = n; return *this; }
                Builder& setOpen() { type = UMARKUP_OPEN; return *this; }
                Builder& setClose() { type = UMARKUP_CLOSE; return *this; }
                Builder& setStandalone() { type = UMARKUP_STANDALONE; return *this; }
                Builder& addOption(const UnicodeString &key, Operand&& value, UErrorCode& status);
                Builder& addAttribute(const UnicodeString &key, Operand&& value, UErrorCode& status);
                Markup build(UErrorCode& status);
                Builder(UErrorCode& status);
                virtual ~Builder();
                Builder(const Builder&) = delete;
                Builder& operator=(const Builder&) = delete;
                Builder(Builder&&) = delete;
                Builder& operator=(Builder&&) = delete;
            }; // class Markup::Builder
 
        private:
            friend class Builder;
            friend class message2::MessageFormatter;
            friend class message2::Serializer;
 
            UMarkupType type;
            UnicodeString name;
            OptionMap options;
            OptionMap attributes;
            const OptionMap& getOptionsInternal() const { return options; }
            const OptionMap& getAttributesInternal() const { return attributes; }
            Markup(UMarkupType, UnicodeString, OptionMap&&, OptionMap&&);
        }; // class Markup

        class U_I18N_API_CLASS Expression : public UObject {
        public:
            U_I18N_API UBool isStandaloneAnnotation() const;
            U_I18N_API UBool isFunctionCall() const;
            U_I18N_API const Operator* getOperator(UErrorCode& status) const;
            U_I18N_API const Operand& getOperand() const;
            U_I18N_API std::vector<Option> getAttributes() const { return attributes.getOptions(); }
            class U_I18N_API Builder : public UMemory {
            private:
                friend class Expression;
 
                bool hasOperand = false;
                bool hasOperator = false;
                Operand rand;
                Operator rator;
                OptionMap::Builder attributes;
            public:
                Builder& setOperand(Operand&& rAnd);
                Builder& setOperator(Operator&& rAtor);
                Builder& addAttribute(const UnicodeString &key, Operand&& value, UErrorCode& status);
                Expression build(UErrorCode& status);
                Builder(UErrorCode& status);
                virtual ~Builder();
                Builder(const Builder&) = delete;
                Builder& operator=(const Builder&) = delete;
                Builder(Builder&&) = delete;
                Builder& operator=(Builder&&) = delete;
            }; // class Expression::Builder

            U_I18N_API friend inline void swap(Expression& e1, Expression& e2) noexcept {
                using std::swap;
 
                swap(e1.rator, e2.rator);
                swap(e1.rand, e2.rand);
                swap(e1.attributes, e2.attributes);
            }

            U_I18N_API Expression(const Expression& other);
            U_I18N_API Expression& operator=(Expression) noexcept;
            U_I18N_API Expression();
            U_I18N_API virtual ~Expression();
        private:
            friend class message2::Serializer;
 
            /*
              Internally, an expression is represented as the application of an optional operator to an operand.
              The operand is always present; for function calls with no operand, it's represented
              as an operand for which `isNull()` is true.
 
              Operator               | Operand
              --------------------------------
              { |42| :fun opt=value } =>  (FunctionName=fun,     | Literal(quoted=true, contents="42")
              options={opt: value})
              { abcd }                =>  null                   | Literal(quoted=false, contents="abcd")
              { : fun opt=value }     =>  (FunctionName=fun,
              options={opt: value})  | NullOperand()
            */
 
            Expression(const Operator &rAtor, const Operand &rAnd, const OptionMap& attrs) : rator(rAtor), rand(rAnd), attributes(attrs) {}
            Expression(const Operand &rAnd, const OptionMap& attrs) : rator(std::nullopt), rand(Operand(rAnd)), attributes(attrs) {}
            Expression(const Operator &rAtor, const OptionMap& attrs) : rator(rAtor), rand(), attributes(attrs) {}
            /* const */ std::optional<Operator> rator;
            /* const */ Operand rand;
            /* const */ OptionMap attributes;
            const OptionMap& getAttributesInternal() const { return attributes; }
        }; // class Expression
 
      class Pattern;
 
  // Despite the comments, `PatternPart` is internal-only
        class U_I18N_API_CLASS PatternPart : public UObject {
        public:
            U_I18N_API UBool isText() const { return std::holds_alternative<UnicodeString>(piece); }
            U_I18N_API UBool isMarkup() const { return std::holds_alternative<Markup>(piece); }
            U_I18N_API UBool isExpression() const { return std::holds_alternative<Expression>(piece); }
            U_I18N_API const Expression& contents() const;
            U_I18N_API const Markup& asMarkup() const;
            U_I18N_API const UnicodeString& asText() const;
            U_I18N_API friend inline void swap(PatternPart& p1, PatternPart& p2) noexcept {
                using std::swap;
 
                swap(p1.piece, p2.piece);
            }

            U_I18N_API PatternPart(const PatternPart& other);
            U_I18N_API PatternPart& operator=(PatternPart) noexcept;
            U_I18N_API virtual ~PatternPart();
            U_I18N_API explicit PatternPart(const UnicodeString& t) : piece(t) {}
            U_I18N_API explicit PatternPart(Expression&& e) : piece(e) {}
            U_I18N_API explicit PatternPart(Markup&& m) : piece(m) {}
            U_I18N_API PatternPart() = default;
        private:
            friend class Pattern;
 
            std::variant<UnicodeString, Expression, Markup> piece;
        }; // class PatternPart

        class U_I18N_API_CLASS Pattern : public UObject {
        private:
            friend class PatternPart;
 
        public:
            #ifndef U_IN_DOXYGEN
            struct U_I18N_API Iterator;
            #endif
            U_I18N_API Iterator begin() const {
                return Iterator(this, 0);
            }

            U_I18N_API Iterator end() const {
                return Iterator(this, len);
            }

            class U_I18N_API Builder : public UMemory {
            private:
                friend class Pattern;
 
                UVector* parts;  // Not a LocalPointer for the same reason as in `SelectorKeys::Builder`
 
            public:
                Builder& add(Expression&& part, UErrorCode& status) noexcept;
                Builder& add(Markup&& part, UErrorCode& status) noexcept;
                Builder& add(UnicodeString&& part, UErrorCode& status) noexcept;
                Pattern build(UErrorCode& status) const noexcept;
                Builder(UErrorCode& status);
                virtual ~Builder();
                Builder(const Builder&) = delete;
                Builder& operator=(const Builder&) = delete;
                Builder(Builder&&) = delete;
                Builder& operator=(Builder&&) = delete;
            }; // class Pattern::Builder

            U_I18N_API Pattern() : parts(LocalArray<PatternPart>()) {}
            U_I18N_API friend inline void swap(Pattern& p1, Pattern& p2) noexcept {
                using std::swap;
 
                swap(p1.bogus, p2.bogus);
                swap(p1.len, p2.len);
                swap(p1.parts, p2.parts);
            }

            U_I18N_API Pattern(const Pattern& other);
            U_I18N_API Pattern& operator=(Pattern) noexcept;
            U_I18N_API virtual ~Pattern();

            struct U_I18N_API Iterator {
            private:
                using iterator_category = std::forward_iterator_tag;
                using difference_type = std::ptrdiff_t;
                using value_type = std::variant<UnicodeString, Expression, Markup>;
                using pointer = value_type*;
                using reference = const value_type&;
 
                friend class Pattern;
                Iterator(const Pattern* p, int32_t i) : pos(i), pat(p) {}
                friend bool operator== (const Iterator& a, const Iterator& b) { return (a.pat == b.pat && a.pos == b.pos); }
 
                int32_t pos;
                const Pattern* pat;
 
            public:
                reference operator*() const {
                    const PatternPart& part = pat->parts[pos];
                    return patternContents(part);
                }

                Iterator operator++() { pos++; return *this; }
                friend bool operator!= (const Iterator& a, const Iterator& b) { return !(a == b); }
            }; // struct Iterator
 
        private:
            friend class Builder;
            friend class message2::MessageFormatter;
            friend class message2::Serializer;
 
            // Set to true if a copy constructor fails;
            // needed in order to distinguish an uninitialized
            // Pattern from a 0-length pattern
            bool bogus = false;
 
            // Possibly-empty array of parts
            int32_t len = 0;
            LocalArray<PatternPart> parts;
 
            Pattern(const UVector& parts, UErrorCode& status);
            // Helper
            static void initParts(Pattern&, const Pattern&);

            int32_t numParts() const;
            const PatternPart& getPart(int32_t i) const;
 
            // Gets around not being able to declare Pattern::Iterator as a friend
            // in PatternPart
            static const std::variant<UnicodeString, Expression, Markup>&
                patternContents(const PatternPart& p) { return p.piece; }
        }; // class Pattern

        class U_I18N_API Variant : public UObject {
        public:
            const Pattern& getPattern() const { return p; }
            const SelectorKeys& getKeys() const { return k; }
            Variant(const SelectorKeys& keys, Pattern&& pattern) : k(keys), p(std::move(pattern)) {}
            friend inline void swap(Variant& v1, Variant& v2) noexcept {
                using std::swap;
 
                swap(v1.k, v2.k);
                swap(v1.p, v2.p);
            }

            Variant& operator=(Variant other) noexcept;
            Variant() = default;
            Variant(const Variant&);
            virtual ~Variant();
        private:
            /* const */ SelectorKeys k;
            /* const */ Pattern p;
        }; // class Variant

        class U_I18N_API Binding : public UObject {
        public:
            const Expression& getValue() const;
            const VariableName& getVariable() const { return var; }
            static Binding input(UnicodeString&& variableName, Expression&& rhs, UErrorCode& errorCode);
            UBool isLocal() const { return local; }
            Binding(const VariableName& v, Expression&& e) : var(v), expr(std::move(e)), local(true), annotation(nullptr) {}
            friend inline void swap(Binding& b1, Binding& b2) noexcept {
                using std::swap;
 
                swap(b1.var, b2.var);
                swap(b1.expr, b2.expr);
                swap(b1.local, b2.local);
                b1.updateAnnotation();
                b2.updateAnnotation();
            }

            Binding(const Binding& other);
            Binding& operator=(Binding) noexcept;
            Binding() : local(true) {}
            virtual ~Binding();
        private:
            friend class message2::Checker;
            friend class message2::MessageFormatter;
            friend class message2::Parser;
            friend class message2::Serializer;
 
            /* const */ VariableName var;
            /* const */ Expression expr;
            /* const */ bool local;
 
            // The following field is always nullptr for a local
            // declaration, and possibly nullptr for an .input declaration
            // If non-null, the referent is a member of `expr` so
            // its lifetime is the same as the lifetime of the enclosing Binding
            // (as long as there's no mutation)
            const Operator* annotation = nullptr;
 
            const OptionMap& getOptionsInternal() const;
 
            bool hasAnnotation() const { return !local && (annotation != nullptr); }
            void updateAnnotation();
        }; // class Binding
 
    // Internal only
 
    #ifndef U_IN_DOXYGEN
    class U_I18N_API_CLASS Matcher : public UObject {
    public:
        U_I18N_API Matcher& operator=(Matcher);
        U_I18N_API Matcher(const Matcher&);
        U_I18N_API friend inline void swap(Matcher& m1, Matcher& m2) noexcept {
            using std::swap;
 
            if (m1.bogus) {
                m2.bogus = true;
                return;
            }
            if (m2.bogus) {
                m1.bogus = true;
                return;
            }
            swap(m1.selectors, m2.selectors);
            swap(m1.numSelectors, m2.numSelectors);
            swap(m1.variants, m2.variants);
            swap(m1.numVariants, m2.numVariants);
        }
        U_I18N_API virtual ~Matcher();
    private:
 
        friend class MFDataModel;
 
        Matcher(VariableName* ss, int32_t ns, Variant* vs, int32_t nv);
        Matcher() {}
 
        // A Matcher may have numSelectors=0 and numVariants=0
        // (this is a data model error, but it's representable).
        // So we have to keep a separate flag to track failed copies.
        bool bogus = false;
 
        // The variables that are being matched on.
        LocalArray<VariableName> selectors;
        // The number of selectors
        int32_t numSelectors = 0;
        // The list of `when` clauses (case arms).
        LocalArray<Variant> variants;
        // The number of variants
        int32_t numVariants = 0;
    }; // class Matcher
    #endif
 
    // -----------------------------------------------------------------------
    // Public MFDataModel class

    class U_I18N_API_CLASS MFDataModel : public UMemory {
        /*
          Classes that represent nodes in the data model are nested inside the
          `MFDataModel` class.
 
          Classes such as `Expression`, `Pattern` and `VariantMap` are immutable and
          are constructed using the builder pattern.
 
          Most classes representing nodes have copy constructors. This is because builders
          contain immutable data that must be copied when calling `build()`, since the builder
          could go out of scope before the immutable result of the builder does. Copying is
          also necessary to prevent unexpected mutation if intermediate builders are saved
          and mutated again after calling `build()`.
 
          The copy constructors perform a deep copy, for example by copying the entire
          list of options for an `Operator` (and copying the entire underlying vector.)
          Some internal fields should be `const`, but are declared as non-`const` to make
          the copy constructor simpler to implement. (These are noted throughout.) In
          other words, those fields are `const` except during the execution of a copy
          constructor.
 
          On the other hand, intermediate `Builder` methods that return a `Builder&`
          mutate the state of the builder, so in code like:
 
          Expression::Builder& exprBuilder = Expression::builder()-> setOperand(foo);
          Expression::Builder& exprBuilder2 = exprBuilder.setOperator(bar);
 
          the call to `setOperator()` would mutate `exprBuilder`, since `exprBuilder`
          and `exprBuilder2` are references to the same object.
 
          An alternate choice would be to make `build()` destructive, so that copying would
          be unnecessary. Or, both copying and moving variants of `build()` could be
          provided. Copying variants of the intermediate `Builder` methods could be
          provided as well, if this proved useful.
        */
    public:
        U_I18N_API std::vector<Binding> getLocalVariables() const {
            std::vector<Binding> result;
            if (!bogus) {
                return toStdVector<Binding>(bindings.getAlias(), bindingsLen);
            }
            return {};
        }

        U_I18N_API std::vector<VariableName> getSelectors() const {
            if (std::holds_alternative<Pattern>(body)) {
                return {};
            }
            const Matcher* match = std::get_if<Matcher>(&body);
            // match must be non-null, given the previous check
            return toStdVector<VariableName>(match->selectors.getAlias(), match->numSelectors);
        }

        U_I18N_API std::vector<Variant> getVariants() const {
            // Return empty vector if no variants
            if (std::holds_alternative<Pattern>(body)) {
                return {};
            }
            const Matcher* match = std::get_if<Matcher>(&body);
            // match must be non-null, given the previous check
            return toStdVector<Variant>(match->variants.getAlias(), match->numVariants);
            return {};
        }

        U_I18N_API const Pattern& getPattern() const;
        class U_I18N_API Builder;
        U_I18N_API MFDataModel();
        U_I18N_API friend inline void swap(MFDataModel& m1, MFDataModel& m2) noexcept {
            using std::swap;
 
            if (m1.bogus) {
                m2.bogus = true;
                return;
            }
            if (m2.bogus) {
                m1.bogus = true;
                return;
            }
            swap(m1.body, m2.body);
            swap(m1.bindings, m2.bindings);
            swap(m1.bindingsLen, m2.bindingsLen);
        }

        U_I18N_API MFDataModel& operator=(MFDataModel) noexcept;
        U_I18N_API MFDataModel(const MFDataModel& other);
        U_I18N_API virtual ~MFDataModel();

        class U_I18N_API Builder : public UMemory {
        private:
            friend class MFDataModel;
 
            void checkDuplicate(const VariableName&, UErrorCode&) const;
            void buildSelectorsMessage(UErrorCode&);
            bool hasPattern = true;
            bool hasSelectors = false;
            Pattern pattern;
            // The following members are not LocalPointers for the same reason as in SelectorKeys::Builder
            UVector* selectors = nullptr;
            UVector* variants = nullptr;
            UVector* bindings = nullptr;
        public:
            Builder& addBinding(Binding&& b, UErrorCode& status);
            Builder& addSelector(VariableName&& selector, UErrorCode& errorCode);
            Builder& addVariant(SelectorKeys&& keys, Pattern&& pattern, UErrorCode& errorCode) noexcept;
            Builder& setPattern(Pattern&& pattern);
            MFDataModel build(UErrorCode& status) const noexcept;
            Builder(UErrorCode& status);
            virtual ~Builder();
            Builder(const Builder&) = delete;
            Builder& operator=(const Builder&) = delete;
            Builder(Builder&&) = delete;
            Builder& operator=(Builder&&) = delete;
        }; // class Builder
 
    private:
        friend class message2::Checker;
        friend class message2::MessageFormatter;
        friend class message2::Serializer;
 
        Pattern empty; // Provided so that `getPattern()` can return a result
                       // if called on a selectors message
        bool hasPattern() const { return std::holds_alternative<Pattern>(body); }
 
        bool bogus = false; // Set if a copy constructor fails
 
        // A message body is either a matcher (selector list and variant list),
        // or a single pattern
        std::variant<Matcher, Pattern> body;
 
        // Bindings for local variables
        /* const */ LocalArray<Binding> bindings;
        int32_t bindingsLen = 0;
 
        const Binding* getLocalVariablesInternal() const;
        const VariableName* getSelectorsInternal() const;
        const Variant* getVariantsInternal() const;
 
        int32_t numSelectors() const {
            const Matcher* matcher = std::get_if<Matcher>(&body);
            return (matcher == nullptr ? 0 : matcher->numSelectors);
        }
        int32_t numVariants() const {
            const Matcher* matcher = std::get_if<Matcher>(&body);
            return (matcher == nullptr ? 0 : matcher->numVariants);
        }
 
        // Helper
        void initBindings(const Binding*);
 
        MFDataModel(const Builder& builder, UErrorCode&) noexcept;
    }; // class MFDataModel
  } // namespace data_model
} // namespace message2
 
U_NAMESPACE_END
 
#if defined(U_REAL_MSVC)
#pragma warning(pop)
#endif
 
#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 // MESSAGEFORMAT_DATA_MODEL_H
 
// eof