abstract_factory.hpp

// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_BASE_ABSTRACT_FACTORY_HPP_
#define GKO_PUBLIC_CORE_BASE_ABSTRACT_FACTORY_HPP_
 
 
#include <type_traits>
#include <unordered_map>
 
#include <ginkgo/core/base/polymorphic_object.hpp>
 
 
namespace gko {
 
 
template <typename AbstractProductType, typename ComponentsType>
class AbstractFactory
    : public EnableAbstractPolymorphicObject<
          AbstractFactory<AbstractProductType, ComponentsType>> {
public:
    using abstract_product_type = AbstractProductType;
    using components_type = ComponentsType;
 
    template <typename... Args>
    std::unique_ptr<abstract_product_type> generate(Args&&... args) const
    {
        auto product =
            this->generate_impl(components_type{std::forward<Args>(args)...});
        for (auto logger : this->loggers_) {
            product->add_logger(logger);
        }
        return product;
    }
 
protected:
    AbstractFactory(std::shared_ptr<const Executor> exec)
        : EnableAbstractPolymorphicObject<AbstractFactory>(std::move(exec))
    {}
 
    virtual std::unique_ptr<abstract_product_type> generate_impl(
        ComponentsType args) const = 0;
};
 
 
template <typename ConcreteFactory, typename ProductType,
          typename ParametersType, typename PolymorphicBase>
class EnableDefaultFactory
    : public EnablePolymorphicObject<ConcreteFactory, PolymorphicBase>,
      public EnablePolymorphicAssignment<ConcreteFactory> {
public:
    friend class EnablePolymorphicObject<ConcreteFactory, PolymorphicBase>;
 
    using product_type = ProductType;
    using parameters_type = ParametersType;
    using polymorphic_base = PolymorphicBase;
    using abstract_product_type =
        typename PolymorphicBase::abstract_product_type;
    using components_type = typename PolymorphicBase::components_type;
 
    template <typename... Args>
    std::unique_ptr<product_type> generate(Args&&... args) const
    {
        auto product = std::unique_ptr<product_type>(static_cast<product_type*>(
            this->polymorphic_base::generate(std::forward<Args>(args)...)
                .release()));
        return product;
    }
 
    const parameters_type& get_parameters() const noexcept
    {
        return parameters_;
    };
 
    static parameters_type create() { return {}; }
 
protected:
    explicit EnableDefaultFactory(std::shared_ptr<const Executor> exec,
                                  const parameters_type& parameters = {})
        : EnablePolymorphicObject<ConcreteFactory, PolymorphicBase>(
              std::move(exec)),
          parameters_{parameters}
    {}
 
    std::unique_ptr<abstract_product_type> generate_impl(
        components_type args) const override
    {
        return std::unique_ptr<abstract_product_type>(
            new product_type(self(), args));
    }
 
private:
    GKO_ENABLE_SELF(ConcreteFactory);
 
    ParametersType parameters_;
};
 
 
template <typename ConcreteParametersType, typename Factory>
class enable_parameters_type {
public:
    using factory = Factory;
 
    template <typename... Args>
    ConcreteParametersType& with_loggers(Args&&... _value)
    {
        this->loggers = {std::forward<Args>(_value)...};
        return *self();
    }
 
    std::unique_ptr<Factory> on(std::shared_ptr<const Executor> exec) const
    {
        ConcreteParametersType copy = *self();
        for (const auto& item : deferred_factories) {
            item.second(exec, copy);
        }
        auto factory = std::unique_ptr<Factory>(new Factory(exec, copy));
        for (auto& logger : loggers) {
            factory->add_logger(logger);
        };
        return factory;
    }
 
protected:
    GKO_ENABLE_SELF(ConcreteParametersType);
 
    std::vector<std::shared_ptr<const log::Logger>> loggers{};
 
    std::unordered_map<std::string,
                       std::function<void(std::shared_ptr<const Executor> exec,
                                          ConcreteParametersType&)>>
        deferred_factories;
};
 
 
#define GKO_CREATE_FACTORY_PARAMETERS(_parameters_name, _factory_name)  \
public:                                                                 \
    class _factory_name;                                                \
    struct _parameters_name##_type                                      \
        : public ::gko::enable_parameters_type<_parameters_name##_type, \
                                               _factory_name>
 
 
namespace detail {
 
 
// Use pointer not the type because std::is_convertible<const type, type> can be
// true.
template <typename From, typename To>
struct is_pointer_convertible : std::is_convertible<From*, To*> {};
 
 
}  // namespace detail
 
 
template <typename FactoryType>
class deferred_factory_parameter {
public:
    deferred_factory_parameter() = default;
 
    deferred_factory_parameter(std::nullptr_t)
    {
        generator_ = [](std::shared_ptr<const Executor>) { return nullptr; };
    }
 
    template <typename ConcreteFactoryType,
              std::enable_if_t<detail::is_pointer_convertible<
                  ConcreteFactoryType, FactoryType>::value>* = nullptr>
    deferred_factory_parameter(std::shared_ptr<ConcreteFactoryType> factory)
    {
        generator_ = [factory =
                          std::shared_ptr<FactoryType>(std::move(factory))](
                         std::shared_ptr<const Executor>) { return factory; };
    }
 
    template <typename ConcreteFactoryType, typename Deleter,
              std::enable_if_t<detail::is_pointer_convertible<
                  ConcreteFactoryType, FactoryType>::value>* = nullptr>
    deferred_factory_parameter(
        std::unique_ptr<ConcreteFactoryType, Deleter> factory)
    {
        generator_ = [factory =
                          std::shared_ptr<FactoryType>(std::move(factory))](
                         std::shared_ptr<const Executor>) { return factory; };
    }
 
    template <typename ParametersType,
              typename U = decltype(std::declval<ParametersType>().on(
                  std::shared_ptr<const Executor>{})),
              std::enable_if_t<detail::is_pointer_convertible<
                  typename U::element_type, FactoryType>::value>* = nullptr>
    deferred_factory_parameter(ParametersType parameters)
    {
        generator_ = [parameters](std::shared_ptr<const Executor> exec)
            -> std::shared_ptr<FactoryType> { return parameters.on(exec); };
    }
 
    std::shared_ptr<FactoryType> on(std::shared_ptr<const Executor> exec) const
    {
        if (this->is_empty()) {
            GKO_NOT_SUPPORTED(*this);
        }
        return generator_(exec);
    }
 
    bool is_empty() const { return !bool(generator_); }
 
private:
    std::function<std::shared_ptr<FactoryType>(std::shared_ptr<const Executor>)>
        generator_;
};
 
 
#define GKO_ENABLE_BUILD_METHOD(_factory_name)                               \
    static auto build()->decltype(_factory_name::create())                   \
    {                                                                        \
        return _factory_name::create();                                      \
    }                                                                        \
    static_assert(true,                                                      \
                  "This assert is used to counter the false positive extra " \
                  "semi-colon warnings")
 
 
#if !(defined(__CUDACC__) || defined(__HIPCC__))
 
#define GKO_FACTORY_PARAMETER(_name, ...)                                    \
    _name{__VA_ARGS__};                                                      \
                                                                             \
    template <typename... Args>                                              \
    auto with_##_name(Args&&... _value)                                      \
        ->std::decay_t<decltype(*(this->self()))>&                           \
    {                                                                        \
        using type = decltype(this->_name);                                  \
        this->_name = type{std::forward<Args>(_value)...};                   \
        return *(this->self());                                              \
    }                                                                        \
    static_assert(true,                                                      \
                  "This assert is used to counter the false positive extra " \
                  "semi-colon warnings")
 
#define GKO_FACTORY_PARAMETER_SCALAR(_name, _default) \
    GKO_FACTORY_PARAMETER(_name, _default)
 
#define GKO_FACTORY_PARAMETER_VECTOR(_name, ...) \
    GKO_FACTORY_PARAMETER(_name, __VA_ARGS__)
#else  // defined(__CUDACC__) || defined(__HIPCC__)
// A workaround for the NVCC compiler - parameter pack expansion does not work
// properly, because while the assignment to a scalar value is translated by
// cudafe into a C-style cast, the parameter pack expansion is not removed and
// `Args&&... args` is still kept as a parameter pack.
#define GKO_FACTORY_PARAMETER(_name, ...)                                    \
    _name{__VA_ARGS__};                                                      \
                                                                             \
    template <typename... Args>                                              \
    auto with_##_name(Args&&... _value)                                      \
        ->std::decay_t<decltype(*(this->self()))>&                           \
    {                                                                        \
        GKO_NOT_IMPLEMENTED;                                                 \
        return *(this->self());                                              \
    }                                                                        \
    static_assert(true,                                                      \
                  "This assert is used to counter the false positive extra " \
                  "semi-colon warnings")
 
#define GKO_FACTORY_PARAMETER_SCALAR(_name, _default)                         \
    _name{_default};                                                          \
                                                                              \
    template <typename Arg>                                                   \
    auto with_##_name(Arg&& _value)->std::decay_t<decltype(*(this->self()))>& \
    {                                                                         \
        using type = decltype(this->_name);                                   \
        this->_name = type{std::forward<Arg>(_value)};                        \
        return *(this->self());                                               \
    }                                                                         \
    static_assert(true,                                                       \
                  "This assert is used to counter the false positive extra "  \
                  "semi-colon warnings")
 
#define GKO_FACTORY_PARAMETER_VECTOR(_name, ...)                             \
    _name{__VA_ARGS__};                                                      \
                                                                             \
    template <typename... Args>                                              \
    auto with_##_name(Args&&... _value)                                      \
        ->std::decay_t<decltype(*(this->self()))>&                           \
    {                                                                        \
        using type = decltype(this->_name);                                  \
        this->_name = type{std::forward<Args>(_value)...};                   \
        return *(this->self());                                              \
    }                                                                        \
    static_assert(true,                                                      \
                  "This assert is used to counter the false positive extra " \
                  "semi-colon warnings")
#endif  // defined(__CUDACC__) || defined(__HIPCC__)
 
#define GKO_DEFERRED_FACTORY_PARAMETER(_name)                                  \
    _name{};                                                                   \
                                                                               \
private:                                                                       \
    using _name##_type = typename decltype(_name)::element_type;               \
                                                                               \
public:                                                                        \
    auto with_##_name(::gko::deferred_factory_parameter<_name##_type> factory) \
        ->std::decay_t<decltype(*(this->self()))>&                             \
    {                                                                          \
        this->_name##_generator_ = std::move(factory);                         \
        this->deferred_factories[#_name] = [](const auto& exec,                \
                                              auto& params) {                  \
            if (!params._name##_generator_.is_empty()) {                       \
                params._name = params._name##_generator_.on(exec);             \
            }                                                                  \
        };                                                                     \
        return *(this->self());                                                \
    }                                                                          \
                                                                               \
private:                                                                       \
    ::gko::deferred_factory_parameter<_name##_type> _name##_generator_;        \
                                                                               \
public:                                                                        \
    static_assert(true,                                                        \
                  "This assert is used to counter the false positive extra "   \
                  "semi-colon warnings")
 
#define GKO_DEFERRED_FACTORY_VECTOR_PARAMETER(_name)                           \
    _name{};                                                                   \
                                                                               \
private:                                                                       \
    using _name##_type = typename decltype(_name)::value_type::element_type;   \
                                                                               \
public:                                                                        \
    template <typename... Args,                                                \
              typename = std::enable_if_t<::std::conjunction<                  \
                  std::is_convertible<Args, ::gko::deferred_factory_parameter< \
                                                _name##_type>>...>::value>>    \
    auto with_##_name(Args&&... factories)                                     \
        ->std::decay_t<decltype(*(this->self()))>&                             \
    {                                                                          \
        this->_name##_generator_ = {                                           \
            ::gko::deferred_factory_parameter<_name##_type>{                   \
                std::forward<Args>(factories)}...};                            \
        this->deferred_factories[#_name] = [](const auto& exec,                \
                                              auto& params) {                  \
            if (!params._name##_generator_.empty()) {                          \
                params._name.clear();                                          \
                for (auto& generator : params._name##_generator_) {            \
                    params._name.push_back(generator.on(exec));                \
                }                                                              \
            }                                                                  \
        };                                                                     \
        return *(this->self());                                                \
    }                                                                          \
    template <typename FactoryType,                                            \
              typename = std::enable_if_t<std::is_convertible<                 \
                  FactoryType,                                                 \
                  ::gko::deferred_factory_parameter<_name##_type>>::value>>    \
    auto with_##_name(const std::vector<FactoryType>& factories)               \
        ->std::decay_t<decltype(*(this->self()))>&                             \
    {                                                                          \
        this->_name##_generator_.clear();                                      \
        for (const auto& factory : factories) {                                \
            this->_name##_generator_.push_back(factory);                       \
        }                                                                      \
        this->deferred_factories[#_name] = [](const auto& exec,                \
                                              auto& params) {                  \
            if (!params._name##_generator_.empty()) {                          \
                params._name.clear();                                          \
                for (auto& generator : params._name##_generator_) {            \
                    params._name.push_back(generator.on(exec));                \
                }                                                              \
            }                                                                  \
        };                                                                     \
        return *(this->self());                                                \
    }                                                                          \
                                                                               \
private:                                                                       \
    std::vector<::gko::deferred_factory_parameter<_name##_type>>               \
        _name##_generator_;                                                    \
                                                                               \
public:                                                                        \
    static_assert(true,                                                        \
                  "This assert is used to counter the false positive extra "   \
                  "semi-colon warnings")
 
 
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_BASE_ABSTRACT_FACTORY_HPP_