messageformat2_function_registry.h

// © 2024 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
 
#include "unicode/utypes.h"
 
#ifndef MESSAGEFORMAT2_FUNCTION_REGISTRY_H
#define MESSAGEFORMAT2_FUNCTION_REGISTRY_H
 
#if U_SHOW_CPLUSPLUS_API
 
#if !UCONFIG_NO_NORMALIZATION
 
#if !UCONFIG_NO_FORMATTING
 
#if !UCONFIG_NO_MF2
 
#include "unicode/messageformat2_data_model_names.h"
#include "unicode/messageformat2_formattable.h"
#include "unicode/ubidi.h"
 
#ifndef U_HIDE_DEPRECATED_API
 
#include <map>
 
U_NAMESPACE_BEGIN
 
class Hashtable;
class UVector;
 
namespace message2 {
 
    using namespace data_model;
 
    class Function;

    class U_I18N_API MFFunctionRegistry : public UObject {
    private:
 
        using FunctionMap = Hashtable; // Map from function names to FunctionFactory*
 
    public:
        const Function* getFunction(const FunctionName& functionName) const;
        UBool getDefaultFormatterNameByType(const UnicodeString& formatterType, FunctionName& name) const;
        class U_I18N_API Builder : public UObject {
        private:
            // Must use raw pointers to avoid instantiating `LocalPointer` on an internal type
            FunctionMap* functions;
            // Mapping from strings (type tags) to FunctionNames
            Hashtable* formattersByType = nullptr;
 
            // Do not define copy constructor/assignment operator
            Builder& operator=(const Builder&) = delete;
            Builder(const Builder&) = delete;
 
        public:
            /*
              Notes about `adoptFormatter()`'s type signature:
 
              Alternative considered: take a non-owned FormatterFactory*
              This is unsafe.
 
              Alternative considered: take a FormatterFactory&
                 This requires getFormatter() to cast the reference to a pointer,
                 as it must return an unowned FormatterFactory* since it can fail.
                 That is also unsafe, since the caller could delete the pointer.
 
              The "TemperatureFormatter" test from the previous ICU4J version doesn't work now,
              as it only works if the `formatterFactory` argument is non-owned.
              If registering a non-owned FormatterFactory is desirable, this could
              be re-thought.
              */
            Builder& adoptFunction(const data_model::FunctionName& functionName,
                                   Function* function,
                                   UErrorCode& errorCode);
            Builder& setDefaultFormatterNameByType(const UnicodeString& type,
                                                   const data_model::FunctionName& functionName,
                                                   UErrorCode& errorCode);
            MFFunctionRegistry build();
            Builder(UErrorCode& errorCode);
            virtual ~Builder();
        }; // class MFFunctionRegistry::Builder

        MFFunctionRegistry& operator=(MFFunctionRegistry&&) noexcept;
        MFFunctionRegistry(MFFunctionRegistry&& other) { *this = std::move(other); }
        virtual ~MFFunctionRegistry();

        static const MFFunctionRegistry* getStandardFunctionsRegistry(UErrorCode &status);
        
    private:
        friend class MessageContext;
        friend class MessageFormatter;
        friend class MF2RegistrySingleton;
 
        // Do not define copy constructor or copy assignment operator
        MFFunctionRegistry& operator=(const MFFunctionRegistry&) = delete;
        MFFunctionRegistry(const MFFunctionRegistry&) = delete;
 
        MFFunctionRegistry(FunctionMap*, Hashtable*);
 
        MFFunctionRegistry() {}
 
        // Debugging; should only be called on a function registry with
        // all the standard functions registered
        void checkFunction(std::u16string_view) const;
        void checkStandard() const;
 
        bool hasFunction(const data_model::FunctionName& f) const;
        void cleanup() noexcept;
 
        // Must use raw pointers to avoid instantiating `LocalPointer` on an internal type
        FunctionMap* functions = nullptr;
        // Mapping from strings (type tags) to FunctionNames
        Hashtable* formattersByType = nullptr;
    }; // class MFFunctionRegistry

    class U_I18N_API_CLASS FunctionContext : public UObject {
        public:
            U_I18N_API const Locale& getLocale() const { return locale; }
            U_I18N_API UMFBidiOption getDirection() const { return dir; }
            U_I18N_API const UnicodeString& getID() const { return id; }

            U_I18N_API const FunctionName& getCalledFunctionName() const { return calledFunction; }

            U_I18N_API FunctionContext withLocale(const Locale& loc) const {
                return FunctionContext(loc, getDirection(), getID(), getCalledFunctionName());
            }
 
        private:
            friend class MessageFormatter;
 
            Locale locale;
            UMFBidiOption dir;
            UnicodeString id;
            const FunctionName& calledFunction;
 
            FunctionContext(const Locale& loc, UMFBidiOption d, UnicodeString i, const FunctionName& calledFn)
                : locale(loc), dir(d), id(i), calledFunction(calledFn) {}
    }; // class FunctionContext
 
    class FunctionValue;

    class U_I18N_API Function : public UObject {
        public:
            virtual LocalPointer<FunctionValue> call(const FunctionContext& context,
                                                     const FunctionValue& operand,
                                                     const FunctionOptions& options,
                                                     UErrorCode& status) const = 0;
            virtual ~Function();
    }; // class Function

    class U_I18N_API_CLASS FunctionValue : public UObject {
        public:
            U_I18N_API virtual UnicodeString formatToString(UErrorCode& status) const {
                if (U_SUCCESS(status)) {
                    status = U_MF_FORMATTING_ERROR;
                }
                return {};
            }

            U_I18N_API virtual const Formattable& unwrap() const { return innerValue; }
            U_I18N_API virtual const FunctionOptions& getResolvedOptions() const { return opts; }
            U_I18N_API virtual UMFDirectionality getDirection() const { return dir; }
            U_I18N_API virtual UMFBidiOption getDirectionAnnotation() const { return inputDir; }
            U_I18N_API virtual UBool isSelectable() const {
                // In the future, this function could return a capability
                // indicating whether this function can format, select, or both.
                return false;
            }

            U_I18N_API virtual UBool isNullOperand() const { return false; }
            U_I18N_API virtual void selectKeys(const UnicodeString* keys,
                                    int32_t keysLen,
                                    int32_t* prefs,
                                    int32_t& prefsLen,
                                    UErrorCode& status) const {
                (void) keys;
                (void) keysLen;
                (void) prefs;
                (void) prefsLen;
                if (U_SUCCESS(status)) {
                    status = U_MF_SELECTOR_ERROR;
                }
            }

            U_I18N_API virtual const FunctionName& getFunctionName() const { return functionName; }
            U_I18N_API virtual const UnicodeString& getFallback() const { return fallback; }
            U_I18N_API virtual ~FunctionValue();
         protected:
            Formattable innerValue;
            FunctionOptions opts;
            FunctionName functionName;
            UnicodeString fallback;
            Locale locale;
            UMFDirectionality dir = U_MF_DIRECTIONALITY_UNKNOWN;
            UMFBidiOption inputDir = U_MF_BIDI_OPTION_INHERIT;
        private:
            friend class FunctionOptions;
 
            // Should only be overridden by BaseValue
            virtual UBool wasCreatedFromLiteral() const { return false; }
    }; // class FunctionValue
 
} // 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_FUNCTION_REGISTRY_H
 
// eof