| Current File : //opt/alt/alt-nodejs20/root/usr/include/unicode/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
// ----------
/**
* `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