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"
 
#ifndef U_HIDE_DEPRECATED_API
 
#include <map>
 
U_NAMESPACE_BEGIN
 
class Hashtable;
class UVector;
 
namespace message2 {
 
    using namespace data_model;
 
    class U_I18N_API FormatterFactory : public UObject {
        // TODO: the coding guidelines say that interface classes
        // shouldn't inherit from UObject, but if I change it so these
        // classes don't, and the individual formatter factory classes
        // inherit from public FormatterFactory, public UObject, then
        // memory leaks ensue
    public:
        virtual Formatter* createFormatter(const Locale& locale, UErrorCode& status) = 0;
        virtual ~FormatterFactory();
        FormatterFactory& operator=(const FormatterFactory&) = delete;
    }; // class FormatterFactory
 
    class U_I18N_API SelectorFactory : public UObject {
    public:
        virtual Selector* createSelector(const Locale& locale, UErrorCode& status) const = 0;
        virtual ~SelectorFactory();
        SelectorFactory& operator=(const SelectorFactory&) = delete;
    }; // class SelectorFactory
 
    class U_I18N_API MFFunctionRegistry : public UObject {
    private:
 
        using FormatterMap = Hashtable; // Map from stringified function names to FormatterFactory*
        using SelectorMap  = Hashtable; // Map from stringified function names to SelectorFactory*
 
    public:
        FormatterFactory* getFormatter(const FunctionName& formatterName) const;
        const SelectorFactory* getSelector(const FunctionName& selectorName) 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
            FormatterMap* formatters;
            SelectorMap* selectors;
            Hashtable* formattersByType;
 
            // 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& adoptFormatter(const data_model::FunctionName& formatterName, FormatterFactory* formatterFactory, UErrorCode& errorCode);
            Builder& setDefaultFormatterNameByType(const UnicodeString& type, const data_model::FunctionName& functionName, UErrorCode& errorCode);
 
            Builder& adoptSelector(const data_model::FunctionName& selectorName, SelectorFactory* selectorFactory, 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();
 
    private:
        friend class MessageContext;
        friend class MessageFormatter;
 
        // Do not define copy constructor or copy assignment operator
        MFFunctionRegistry& operator=(const MFFunctionRegistry&) = delete;
        MFFunctionRegistry(const MFFunctionRegistry&) = delete;
 
        MFFunctionRegistry(FormatterMap* f, SelectorMap* s, Hashtable* byType);
 
        MFFunctionRegistry() {}
 
        // Debugging; should only be called on a function registry with
        // all the standard functions registered
        void checkFormatter(const char*) const;
        void checkSelector(const char*) const;
        void checkStandard() const;
 
        bool hasFormatter(const data_model::FunctionName& f) const;
        bool hasSelector(const data_model::FunctionName& s) const;
        void cleanup() noexcept;
 
        // Must use raw pointers to avoid instantiating `LocalPointer` on an internal type
        FormatterMap* formatters = nullptr;
        SelectorMap* selectors = nullptr;
        // Mapping from strings (type tags) to FunctionNames
        Hashtable* formattersByType = nullptr;
    }; // class MFFunctionRegistry
 
    class U_I18N_API Formatter : public UObject {
    public:
        virtual FormattedPlaceholder format(FormattedPlaceholder&& toFormat,
                                      FunctionOptions&& options,
                                      UErrorCode& status) const = 0;
        virtual ~Formatter();
    }; // class Formatter
 
    class U_I18N_API Selector : public UObject {
    public:
        virtual void selectKey(FormattedPlaceholder&& toFormat,
                               FunctionOptions&& options,
                               const UnicodeString* keys,
                               int32_t keysLen,
                               UnicodeString* prefs,
                               int32_t& prefsLen,
                               UErrorCode& status) const = 0;
        // Note: This takes array arguments because the internal MessageFormat code has to
        // call this method, and can't include any code that constructs std::vectors.
        virtual ~Selector();
    }; // class Selector
 
} // 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