EIC code displayed by LXR master/​include/​unicode/​messageformat2_formattable.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-01-07 10:23:59

 // © 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
     // ----------
 
     /**
      * `FormattableObject` is an abstract class that can be implemented in order to define
      * an arbitrary class that can be passed to a custom formatter or selector function.
      * To be passed in such a way, it must be wrapped in a `Formattable` object.
      *
      * @internal ICU 75 technology preview
      * @deprecated This API is for technology preview only.
      */
     class U_I18N_API FormattableObject : public UObject {
     public:
         /**
          * Returns an arbitrary string representing the type of this object.
          * It's up to the implementor of this class, as well as the implementors
          * of any custom functions that rely on particular values of this tag
          * corresponding to particular classes that the object contents can be
          * downcast to, to ensure that the type tags are used soundly.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         virtual const UnicodeString& tag() const = 0;
         /**
          * Destructor.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         virtual ~FormattableObject();
     }; // class FormattableObject
 
     class Formattable;
 } // namespace message2
 
 U_NAMESPACE_END
 
 /// @cond DOXYGEN_IGNORE
 // 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(U_REAL_MSVC) && defined(_MSVC_STL_VERSION)
 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>;
 #endif
 /// @endcond
 
 U_NAMESPACE_BEGIN
 
 namespace message2 {
     /**
      * The `Formattable` class represents a typed value that can be formatted,
      * originating either from a message argument or a literal in the code.
      * ICU's Formattable class is not used in MessageFormat 2 because it's unsafe to copy an
      * icu::Formattable value that contains an object. (See ICU-20275).
      *
      * `Formattable` is immutable (not deeply immutable) and
      * is movable and copyable.
      * (Copying does not do a deep copy when the wrapped value is an array or
      * object. Likewise, while a pointer to a wrapped array or object is `const`,
      * the referents of the pointers may be mutated by other code.)
      *
      * @internal ICU 75 technology preview
      * @deprecated This API is for technology preview only.
      */
     class U_I18N_API Formattable : public UObject {
     public:
 
         /**
          * Gets the data type of this Formattable object.
          * @return    the data type of this Formattable object.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         UFormattableType getType() const;
 
         /**
          * Gets the double value of this object. If this object is not of type
          * UFMT_DOUBLE, then the result is undefined and the error code is set.
          *
          * @param status Input/output error code.
          * @return    the double value of this object.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         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;
         }
 
         /**
          * Gets the long value of this object. If this object is not of type
          * UFMT_LONG then the result is undefined and the error code is set.
          *
          * @param status Input/output error code.
          * @return    the long value of this object.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         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;
         }
 
         /**
          * Gets the int64 value of this object. If this object is not of type
          * kInt64 then the result is undefined and the error code is set.
          * If conversion to int64 is desired, call getInt64()
          *
          * @param status Input/output error code.
          * @return    the int64 value of this object.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         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;
         }
 
         /**
          * Gets the int64 value of this object. If this object is of a numeric
          * type and the magnitude is too large to fit in an int64, then
          * the maximum or minimum int64 value, as appropriate, is returned
          * and the status is set to U_INVALID_FORMAT_ERROR.  If the
          * magnitude fits in an int64, then a casting conversion is
          * performed, with truncation of any fractional part. If this object is
          * not a numeric type, then 0 is returned and
          * the status is set to U_INVALID_FORMAT_ERROR.
          * @param status the error code
          * @return    the int64 value of this object.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         int64_t         getInt64(UErrorCode& status) const;
         /**
          * Gets the string value of this object. If this object is not of type
          * kString then the result is undefined and the error code is set.
          *
          * @param status Input/output error code.
          * @return          A reference to the string value of this object.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         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;
         }
 
         /**
          * Gets the Date value of this object. If this object is not of type
          * kDate then the result is undefined and the error code is set.
          *
          * @param status Input/output error code.
          * @return    the Date value of this object.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         UDate getDate(UErrorCode& status) const {
             if (U_SUCCESS(status)) {
                 if (isDate()) {
                     return *std::get_if<double>(&contents);
                 }
                 status = U_ILLEGAL_ARGUMENT_ERROR;
             }
             return 0;
         }
 
         /**
          * Returns true if the data type of this Formattable object
          * is kDouble
          * @return true if this is a pure numeric object
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         UBool isNumeric() const { return (getType() == UFMT_DOUBLE || getType() == UFMT_LONG || getType() == UFMT_INT64); }
 
         /**
          * Gets the array value and count of this object. If this object
          * is not of type kArray then the result is undefined and the error code is set.
          *
          * @param count    fill-in with the count of this object.
          * @param status Input/output error code.
          * @return         the array value of this object.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         const Formattable* getArray(int32_t& count, UErrorCode& status) const;
 
         /**
          * Returns a pointer to the FormattableObject contained within this
          * formattable, or if this object does not contain a FormattableObject,
          * returns nullptr and sets the error code.
          *
          * @param status Input/output error code.
          * @return a FormattableObject pointer, or nullptr
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         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;
         }
         /**
          * Non-member swap function.
          * @param f1 will get f2's contents
          * @param f2 will get f1's contents
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         friend inline void swap(Formattable& f1, Formattable& f2) noexcept {
             using std::swap;
 
             swap(f1.contents, f2.contents);
             swap(f1.holdsDate, f2.holdsDate);
         }
         /**
          * Copy constructor.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         Formattable(const Formattable&);
         /**
          * Assignment operator
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         Formattable& operator=(Formattable) noexcept;
         /**
          * Default constructor. Leaves the Formattable in a
          * valid but undefined state.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         Formattable() : contents(0.0) {}
         /**
          * String constructor.
          *
          * @param s A string to wrap as a Formattable.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         Formattable(const UnicodeString& s) : contents(s) {}
         /**
          * Double constructor.
          *
          * @param d A double value to wrap as a Formattable.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         Formattable(double d) : contents(d) {}
         /**
          * Int64 constructor.
          *
          * @param i An int64 value to wrap as a Formattable.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         Formattable(int64_t i) : contents(i) {}
         /**
          * Date factory method.
          *
          * @param d A UDate value to wrap as a Formattable.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         static Formattable forDate(UDate d) {
             Formattable f;
             f.contents = d;
             f.holdsDate = true;
             return f;
         }
         /**
          * Creates a Formattable object of an appropriate numeric type from a
          * a decimal number in string form.  The Formattable will retain the
          * full precision of the input in decimal format, even when it exceeds
          * what can be represented by a double or int64_t.
          *
          * @param number  the unformatted (not localized) string representation
          *                     of the Decimal number.
          * @param status  the error code.  Possible errors include U_INVALID_FORMAT_ERROR
          *                if the format of the string does not conform to that of a
          *                decimal number.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         static Formattable forDecimal(std::string_view number, UErrorCode& status);
         /**
          * Array constructor.
          *
          * @param arr An array of Formattables, which is adopted.
          * @param len The length of the array.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         Formattable(const Formattable* arr, int32_t len) : contents(std::pair(arr, len)) {}
         /**
          * Object constructor.
          *
          * @param obj A FormattableObject (not adopted).
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         Formattable(const FormattableObject* obj) : contents(obj) {}
         /**
          * Destructor.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         virtual ~Formattable();
         /**
          * Converts the Formattable object to an ICU Formattable object.
          * If this has type UFMT_OBJECT or kArray, then `status` is set to
          * U_ILLEGAL_ARGUMENT_ERROR.
          *
          * @param status Input/output error code.
          * @return An icu::Formattable value with the same value as this.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         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
 
 /**
  * Internal use only, but has to be included here as part of the implementation
  * of the header-only `FunctionOptions::getOptions()` method
  *
  *  A `ResolvedFunctionOption` represents the result of evaluating
  * a single named function option. It pairs the given name with the `Formattable`
  * value resulting from evaluating the option's value.
  *
  * `ResolvedFunctionOption` is immutable and is not copyable or movable.
  *
  * @internal ICU 75 technology preview
  * @deprecated This API is for technology preview only.
  */
 #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
 
 /**
  * Mapping from option names to `message2::Formattable` objects, obtained
  * by calling `getOptions()` on a `FunctionOptions` object.
  *
  * @internal ICU 75 technology preview
  * @deprecated This API is for technology preview only.
  */
 using FunctionOptionsMap = std::map<UnicodeString, message2::Formattable>;
 
 /**
  * Structure encapsulating named options passed to a custom selector or formatter.
  *
  * @internal ICU 75 technology preview
  * @deprecated This API is for technology preview only.
  */
 class U_I18N_API FunctionOptions : public UObject {
  public:
     /**
      * Returns a map of all name-value pairs provided as options to this function.
      * The syntactic order of options is not guaranteed to
      * be preserved.
      *
      * This class is immutable and movable but not copyable.
      *
      * @return           A map from strings to `message2::Formattable` objects representing
      *                   the results of resolving each option value.
      *
      * @internal ICU 75 technology preview
      * @deprecated This API is for technology preview only.
      */
     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;
     }
     /**
      * Default constructor.
      * Returns an empty mapping.
      *
      * @internal ICU 75 technology preview
      * @deprecated This API is for technology preview only.
      */
     FunctionOptions() { options = nullptr; }
     /**
      * Destructor.
      *
      * @internal ICU 75 technology preview
      * @deprecated This API is for technology preview only.
      */
     virtual ~FunctionOptions();
     /**
      * Move assignment operator:
      * The source FunctionOptions will be left in a valid but undefined state.
      *
      * @internal ICU 75 technology preview
      * @deprecated This API is for technology preview only.
      */
     FunctionOptions& operator=(FunctionOptions&&) noexcept;
     /**
      * Move constructor:
      * The source FunctionOptions will be left in a valid but undefined state.
      *
      * @internal ICU 75 technology preview
      * @deprecated This API is for technology preview only.
      */
     FunctionOptions(FunctionOptions&&);
     /**
      * Copy constructor.
      *
      * @internal ICU 75 technology preview
      * @deprecated This API is for technology preview only.
      */
     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.
 
     /**
      * A `FormattedValue` represents the result of formatting a `message2::Formattable`.
      * It contains either a string or a formatted number. (More types could be added
      * in the future.)
      *
      * `FormattedValue` is immutable and movable. It is not copyable.
      *
      * @internal ICU 75 technology preview
      * @deprecated This API is for technology preview only.
      */
     class U_I18N_API FormattedValue : public UObject {
     public:
         /**
          * Formatted string constructor.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         explicit FormattedValue(const UnicodeString&);
         /**
          * Formatted number constructor.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         explicit FormattedValue(number::FormattedNumber&&);
         /**
          * Default constructor. Leaves the FormattedValue in
          * a valid but undefined state.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         FormattedValue() : type(kString) {}
         /**
          * Returns true iff this is a formatted string.
          *
          * @return True if and only if this value is a formatted string.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         bool isString() const { return type == kString; }
         /**
          * Returns true iff this is a formatted number.
          *
          * @return True if and only if this value is a formatted number.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         bool isNumber() const { return type == kNumber; }
         /**
          * Gets the string contents of this value. If !isString(), then
          * the result is undefined.
          * @return          A reference to a formatted string.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         const UnicodeString& getString() const { return stringOutput; }
         /**
          * Gets the number contents of this value. If !isNumber(), then
          * the result is undefined.
          * @return          A reference to a formatted number.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         const number::FormattedNumber& getNumber() const { return numberOutput; }
         /**
          * Move assignment operator:
          * The source FormattedValue will be left in a valid but undefined state.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         FormattedValue& operator=(FormattedValue&&) noexcept;
         /**
          * Move constructor:
          * The source FormattedValue will be left in a valid but undefined state.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         FormattedValue(FormattedValue&& other) { *this = std::move(other); }
         /**
          * Destructor.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         virtual ~FormattedValue();
     private:
         enum Type {
             kString,
             kNumber
         };
         Type type;
         UnicodeString stringOutput;
         number::FormattedNumber numberOutput;
     }; // class FormattedValue
 
     /**
      * A `FormattablePlaceholder` encapsulates an input value (a `message2::Formattable`)
      * together with an optional output value (a `message2::FormattedValue`).
      *  More information, such as source line/column numbers, could be added to the class
      * in the future.
      *
      * `FormattablePlaceholder` is immutable (not deeply immutable) and movable.
      * It is not copyable.
      *
      * @internal ICU 75 technology preview
      * @deprecated This API is for technology preview only.
      */
     class U_I18N_API FormattedPlaceholder : public UObject {
     public:
         /**
          * Fallback constructor. Constructs a value that represents a formatting error,
          * without recording an input `Formattable` as the source.
          *
          * @param s An error string. (See the MessageFormat specification for details
          *        on fallback strings.)
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         explicit FormattedPlaceholder(const UnicodeString& s) : fallback(s), type(kFallback) {}
         /**
          * Constructor for fully formatted placeholders.
          *
          * @param input A `FormattedPlaceholder` containing the fallback string and source
          *        `Formattable` used to construct the formatted value.
          * @param output A `FormattedValue` representing the formatted output of `input`.
          *        Passed by move.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         FormattedPlaceholder(const FormattedPlaceholder& input, FormattedValue&& output)
             : fallback(input.fallback), source(input.source),
             formatted(std::move(output)), previousOptions(FunctionOptions()), type(kEvaluated) {}
         /**
          * Constructor for fully formatted placeholders with options.
          *
          * @param input A `FormattedPlaceholder` containing the fallback string and source
          *        `Formattable` used to construct the formatted value.
          * @param opts Function options that were used to construct `output`. May be the empty map.
          * @param output A `FormattedValue` representing the formatted output of `input`.
          *        Passed by move.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         FormattedPlaceholder(const FormattedPlaceholder& input, FunctionOptions&& opts, FormattedValue&& output)
             : fallback(input.fallback), source(input.source),
             formatted(std::move(output)), previousOptions(std::move(opts)), type(kEvaluated) {}
         /**
          * Constructor for unformatted placeholders.
          *
          * @param input A `Formattable` object.
          * @param fb Fallback string to use if an error occurs while formatting the input.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         FormattedPlaceholder(const Formattable& input, const UnicodeString& fb)
             : fallback(fb), source(input), type(kUnevaluated) {}
         /**
          * Default constructor. Leaves the FormattedPlaceholder in a
          * valid but undefined state.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         FormattedPlaceholder() : type(kNull) {}
         /**
          * Returns the source `Formattable` value for this placeholder.
          * The result is undefined if this is a null operand.
          *
          * @return A message2::Formattable value.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         const message2::Formattable& asFormattable() const;
         /**
          * Returns true iff this is a fallback placeholder.
          *
          * @return True if and only if this placeholder was constructed from a fallback string,
          *         with no `Formattable` source or formatting output.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         bool isFallback() const { return type == kFallback; }
         /**
          * Returns true iff this is a null placeholder.
          *
          * @return True if and only if this placeholder represents the absent argument to a formatter
          *         that was invoked without an argument.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         bool isNullOperand() const { return type == kNull; }
         /**
          * Returns true iff this has formatting output.
          *
          * @return True if and only if this was constructed from both an input `Formattable` and
          *         output `FormattedValue`.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         bool isEvaluated() const { return (type == kEvaluated); }
         /**
          * Returns true iff this represents a valid argument to the formatter.
          *
          * @return True if and only if this is neither the null argument nor a fallback placeholder.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         bool canFormat() const { return !(isFallback() || isNullOperand()); }
         /**
          * Gets the fallback value of this placeholder, to be used in its place if an error occurs while
          * formatting it.
          * @return          A reference to this placeholder's fallback string.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         const UnicodeString& getFallback() const { return fallback; }
         /**
          * Returns the options of this placeholder. The result is the empty map if !isEvaluated().
          * @return A reference to an option map, capturing the options that were used
          *         in producing the output of this `FormattedPlaceholder`
          *         (or empty if there is no output)
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         const FunctionOptions& options() const { return previousOptions; }
 
         /**
          * Returns the formatted output of this placeholder. The result is undefined if !isEvaluated().
          * @return          A fully formatted `FormattedPlaceholder`.
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         const FormattedValue& output() const { return formatted; }
         /**
          * Move assignment operator:
          * The source FormattedPlaceholder will be left in a valid but undefined state.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         FormattedPlaceholder& operator=(FormattedPlaceholder&&) noexcept;
         /**
          * Move constructor:
          * The source FormattedPlaceholder will be left in a valid but undefined state.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         FormattedPlaceholder(FormattedPlaceholder&& other) { *this = std::move(other); }
         /**
          * Formats this as a string, using defaults.  If this is
          * either the null operand or is a fallback value, the return value is the result of formatting the
          * fallback value (which is the default fallback string if this is the null operand).
          * If there is no formatted output and the input is object- or array-typed,
          * then the argument is treated as a fallback value, since there is no default formatter
          * for objects or arrays.
          *
          * @param locale The locale to use for formatting numbers or dates
          * @param status Input/output error code
          * @return The result of formatting this placeholder.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for technology preview only.
          */
         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
 
     /**
      * Not yet implemented: The result of a message formatting operation. Based on
      * ICU4J's FormattedMessage.java.
      *
      * The class will contain information allowing the result to be viewed as a string,
      * iterator, etc. (TBD)
      *
      * @internal ICU 75 technology preview
      * @deprecated This API is for technology preview only.
      */
     class U_I18N_API FormattedMessage : public icu::FormattedValue {
     public:
         /**
          * Not yet implemented.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for ICU internal use only.
          */
         FormattedMessage(UErrorCode& status) {
             if (U_SUCCESS(status)) {
                 status = U_UNSUPPORTED_ERROR;
             }
         }
         /**
          * Not yet implemented.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for ICU internal use only.
          */
         int32_t length(UErrorCode& status) const {
             if (U_SUCCESS(status)) {
                 status = U_UNSUPPORTED_ERROR;
             }
             return -1;
         }
         /**
          * Not yet implemented.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for ICU internal use only.
          */
         char16_t charAt(int32_t index, UErrorCode& status) const {
             (void) index;
             if (U_SUCCESS(status)) {
                 status = U_UNSUPPORTED_ERROR;
             }
             return 0;
         }
         /**
          * Not yet implemented.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for ICU internal use only.
          */
         StringPiece subSequence(int32_t start, int32_t end, UErrorCode& status) const {
             (void) start;
             (void) end;
             if (U_SUCCESS(status)) {
                 status = U_UNSUPPORTED_ERROR;
             }
             return "";
         }
         /**
          * Not yet implemented.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for ICU internal use only.
          */
         UnicodeString toString(UErrorCode& status) const override {
             if (U_SUCCESS(status)) {
                 status = U_UNSUPPORTED_ERROR;
             }
             return {};
         }
         /**
          * Not yet implemented.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for ICU internal use only.
          */
         UnicodeString toTempString(UErrorCode& status) const override {
             if (U_SUCCESS(status)) {
                 status = U_UNSUPPORTED_ERROR;
             }
             return {};
         }
         /**
          * Not yet implemented.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for ICU internal use only.
          */
         Appendable& appendTo(Appendable& appendable, UErrorCode& status) const override {
             if (U_SUCCESS(status)) {
                 status = U_UNSUPPORTED_ERROR;
             }
             return appendable;
         }
         /**
          * Not yet implemented.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for ICU internal use only.
          */
         UBool nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode& status) const override {
             (void) cfpos;
             if (U_SUCCESS(status)) {
                 status = U_UNSUPPORTED_ERROR;
             }
             return false;
         }
         /**
          * Not yet implemented.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for ICU internal use only.
          */
         CharacterIterator* toCharacterIterator(UErrorCode& status) {
             if (U_SUCCESS(status)) {
                 status = U_UNSUPPORTED_ERROR;
             }
             return nullptr;
         }
         /**
          * Destructor.
          *
          * @internal ICU 75 technology preview
          * @deprecated This API is for ICU internal use only.
          */
         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

This page was automatically generated by the 2.3.7 LXR engine. The LXR team