messageformat2.h

Go to the documentation of this file.

// © 2024 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
 
#include "unicode/utypes.h"
 
#ifndef MESSAGEFORMAT2_H
#define MESSAGEFORMAT2_H
 
#if U_SHOW_CPLUSPLUS_API
 
#if !UCONFIG_NO_NORMALIZATION
 
#if !UCONFIG_NO_FORMATTING
 
#if !UCONFIG_NO_MF2

 
#include "unicode/messageformat2_arguments.h"
#include "unicode/messageformat2_data_model.h"
#include "unicode/messageformat2_function_registry.h"
#include "unicode/normalizer2.h"
#include "unicode/unistr.h"
 
#ifndef U_HIDE_DEPRECATED_API
 
U_NAMESPACE_BEGIN
 
namespace message2 {
 
    class Environment;
    class MessageContext;
    class StaticErrors;
    class InternalValue;
    class BaseValue;

    class U_I18N_API_CLASS MessageFormatter : public UObject {
        // Note: This class does not currently inherit from the existing
        // `Format` class.
    public:
        U_I18N_API MessageFormatter& operator=(MessageFormatter&&) noexcept;
        U_I18N_API virtual ~MessageFormatter();

        U_I18N_API UnicodeString formatToString(const MessageArguments& arguments, UErrorCode& status);

        U_I18N_API FormattedMessage format(const MessageArguments& arguments, UErrorCode& status) const {
            (void) arguments;
            if (U_SUCCESS(status)) {
                status = U_UNSUPPORTED_ERROR;
            }
            return FormattedMessage(status);
        }

        U_I18N_API const Locale& getLocale() const { return locale; }

        U_I18N_API UnicodeString getPattern() const;

        U_I18N_API const MFDataModel& getDataModel() const;

        typedef enum UMFErrorHandlingBehavior {
            U_MF_BEST_EFFORT = 0,
            U_MF_STRICT
        } UMFErrorHandlingBehavior;

        typedef enum UMFBidiContext {
            U_MF_BIDI_CONTEXT_LTR = 0,
            U_MF_BIDI_CONTEXT_RTL,
            U_MF_BIDI_CONTEXT_AUTO,
            U_MF_BIDI_CONTEXT_DEFAULT = U_MF_BIDI_CONTEXT_AUTO
        } UMFBidiContext;

        class U_I18N_API_CLASS Builder : public UObject {
        private:
            friend class MessageFormatter;
 
            // The pattern to be parsed to generate the formatted message
            UnicodeString pattern;
            bool hasPattern = false;
            bool hasDataModel = false;
            // The data model to be used to generate the formatted message
            // Initialized either by `setDataModel()`, or by the parser
            // through a call to `setPattern()`
            MFDataModel dataModel;
            // Normalized representation of the pattern;
            // ignored if `setPattern()` wasn't called
            UnicodeString normalizedInput;
            // Errors (internal representation of parse errors)
            // Ignored if `setPattern()` wasn't called
            StaticErrors* errors;
            Locale locale;
            // Not owned
            const MFFunctionRegistry* customMFFunctionRegistry;
            // Error behavior; see comment in `MessageFormatter` class
            bool signalErrors = false;
            // Bidi isolation strategy
            UMFBidiIsolationStrategy bidiIsolationStrategy = U_MF_BIDI_DEFAULT;
            // Message directionality
            MessageFormatter::UMFBidiContext msgdir = U_MF_BIDI_CONTEXT_DEFAULT;
            // Bidi isolation style
            UMFBidiIsolationStyle bidiStyle = U_MF_BIDI_STYLE_DEFAULT;
 
            void clearState();
        public:
            U_I18N_API Builder& setLocale(const Locale& locale);
            U_I18N_API Builder& setPattern(const UnicodeString& pattern,
                                           UParseError& parseError,
                                           UErrorCode& status);
            U_I18N_API Builder& setFunctionRegistry(const MFFunctionRegistry& functionRegistry);
            U_I18N_API Builder& setDataModel(MFDataModel&& dataModel);
            U_I18N_API Builder& setErrorHandlingBehavior(UMFErrorHandlingBehavior type);
            U_I18N_API Builder& setBidiIsolationStrategy(UMFBidiIsolationStrategy strategy);
            U_I18N_API Builder& setBidiIsolationStyle(UMFBidiIsolationStyle style);
            U_I18N_API Builder& setBidiContext(UMFBidiContext dir);
            U_I18N_API MessageFormatter build(UErrorCode& status) const;
            U_I18N_API Builder(UErrorCode& status);
            U_I18N_API virtual ~Builder();
        }; // class MessageFormatter::Builder

        U_I18N_API const UnicodeString& getNormalizedPattern() const { return normalizedInput; }
 
    private:
        friend class Builder;
        friend class Checker;
        friend class MessageArguments;
        friend class MessageContext;
 
        MessageFormatter(const MessageFormatter::Builder& builder, UErrorCode &status);
 
        MessageFormatter() = delete; // default constructor not implemented
 
        // Do not define default assignment operator
        const MessageFormatter &operator=(const MessageFormatter &) = delete;
 
        // Selection methods
 
        // Takes a vector of FormattedPlaceholders
        void resolveSelectors(MessageContext&, Environment& env, UErrorCode&, UVector&) const;
        // Takes a vector of vectors of strings (input) and a vector of PrioritizedVariants (output)
        void filterVariants(const UVector&, UVector&, UErrorCode&) const;
        // Takes a vector of vectors of strings (input) and a vector of PrioritizedVariants (input/output)
        void sortVariants(const UVector&, UVector&, UErrorCode&) const;
        // Takes a vector of strings (input) and a vector of strings (output)
        void matchSelectorKeys(const UVector&, MessageContext&, InternalValue&& rv, UVector&, UErrorCode&) const;
        // Takes a vector of FormattedPlaceholders (input),
        // and a vector of vectors of strings (output)
        void resolvePreferences(MessageContext&, UVector&, UVector&, UErrorCode&) const;
 
        bool checkSelectOption(const FunctionValue&) const;
 
        // Formatting methods
        [[nodiscard]] InternalValue evalLiteral(const UnicodeString&, const data_model::Literal&, UErrorCode&) const;
        [[nodiscard]] UnicodeString& bidiIsolate(UMFBidiOption, UMFDirectionality, UnicodeString&) const;
        void formatPattern(MessageContext&, Environment&, const data_model::Pattern&, UErrorCode&, UnicodeString&) const;
        FunctionContext makeFunctionContext(const FunctionOptions&, const FunctionName&) const;
        [[nodiscard]] InternalValue& apply(Environment&, const FunctionName&, InternalValue&, FunctionOptions&&,
                                           MessageContext&, UErrorCode&) const;
        [[nodiscard]] InternalValue& evalExpression(const UnicodeString&, Environment&, const data_model::Expression&, MessageContext&, UErrorCode&) const;
        [[nodiscard]] FunctionOptions resolveOptions(Environment& env, const OptionMap&, MessageContext&, UErrorCode&) const;
        [[nodiscard]] InternalValue& evalOperand(const UnicodeString&, Environment&, const data_model::Operand&, MessageContext&, UErrorCode&) const;
        bool operandToStringWithBadOptionError(MessageContext&, Environment&, const Operand&, UnicodeString&, UErrorCode&) const;
        void validateUOptionsOnMarkup(MessageContext&, Environment&, const Markup&, UErrorCode&) const;
        [[nodiscard]] InternalValue& evalVariableReference(const UnicodeString&, Environment&, const data_model::VariableName&, MessageContext&, UErrorCode&) const;
        [[nodiscard]] InternalValue evalArgument(const UnicodeString&, const data_model::VariableName&, MessageContext&, UErrorCode&) const;
        void formatSelectors(MessageContext& context, Environment& env, UErrorCode &status, UnicodeString& result) const;
 
        // Function registry methods
        bool hasCustomMFFunctionRegistry() const {
            return (customMFFunctionRegistry != nullptr);
        }
 
        // Precondition: custom function registry exists
        // Note: this is non-const because the values in the MFFunctionRegistry are mutable
        // (a FormatterFactory can have mutable state)
        const MFFunctionRegistry& getCustomMFFunctionRegistry() const;
 
        bool isCustomFunction(const FunctionName&) const;
        bool isBuiltInFunction(const FunctionName&) const;
        bool isFunction(const FunctionName& fn) const { return isBuiltInFunction(fn) || isCustomFunction(fn); }
        void setNotSelectableError(MessageContext&, const InternalValue&, UErrorCode&) const;
        const Function* lookupFunction(const FunctionName&, UErrorCode&) const;
        bool getDefaultFormatterNameByType(const UnicodeString&, FunctionName&) const;
 
        // Checking for resolution errors
        void checkDeclarations(MessageContext&, Environment*&, UErrorCode&) const;
        void check(MessageContext&, const Environment&, const data_model::Expression&, UErrorCode&) const;
        void check(MessageContext&, const Environment&, const data_model::Operand&, UErrorCode&) const;
        void check(MessageContext&, const Environment&, const OptionMap&, UErrorCode&) const;
 
        void initErrors(UErrorCode&);
        void clearErrors() const;
        void cleanup() noexcept;
 
        // The locale this MessageFormatter was created with
        /* const */ Locale locale;
 
        // Registry for built-in functions
        const MFFunctionRegistry *standardMFFunctionRegistry;
        // Registry for custom functions; may be null if no custom registry supplied
        // Note: this is *not* owned by the MessageFormatter object
        // The reason for this choice is to have a non-destructive MessageFormatter::Builder,
        // while also not requiring the function registry to be deeply-copyable. Making the
        // function registry copyable would impose a requirement on any implementations
        // of the FormatterFactory and SelectorFactory interfaces to implement a custom
        // clone() method, which is necessary to avoid sharing between copies of the
        // function registry (and thus double-frees)
        // Not deeply immutable (the values in the function registry are mutable,
        // as a FormatterFactory can have mutable state
        const MFFunctionRegistry* customMFFunctionRegistry;
 
        // Data model, representing the parsed message
        MFDataModel dataModel;
 
        // Normalized version of the input string (optional whitespace removed)
        UnicodeString normalizedInput;
 
        // Errors -- only used while parsing and checking for data model errors; then
        // the MessageContext keeps track of errors
        // Must be a raw pointer to avoid including the internal header file
        // defining StaticErrors
        // Owned by `this`
        StaticErrors* errors = nullptr;
 
        // Error handling behavior.
        // If true, then formatting methods set their UErrorCode arguments
        // to signal MessageFormat errors, and no useful output is returned.
        // If false, then MessageFormat errors are not signaled and the
        // formatting methods return best-effort output.
        // The default is false.
        bool signalErrors = false;
 
        // Bidi isolation strategy.
        UMFBidiIsolationStrategy bidiIsolationStrategy = U_MF_BIDI_DEFAULT;
 
        // Message directionality
        // Inferred from locale by default
        UMFDirectionality msgdir = U_MF_DIRECTIONALITY_DEFAULT;
 
        // Bidi isolation style
        UMFBidiIsolationStyle bidiIsolationStyle = U_MF_BIDI_STYLE_DEFAULT;
 
    }; // class MessageFormatter
 
} // namespace message2
 
U_NAMESPACE_END
 
#endif // U_HIDE_DEPRECATED_API
 
#endif /* #if !UCONFIG_NO_MF2 */
 
#endif /* #if !UCONFIG_NO_FORMATTING */
 
#endif /* #if !UCONFIG_NO_NORMALIZATION */
 
#endif /* U_SHOW_CPLUSPLUS_API */
 
#endif // MESSAGEFORMAT2_H
 
// eof