registry.hpp

// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_CONFIG_REGISTRY_HPP_
#define GKO_PUBLIC_CORE_CONFIG_REGISTRY_HPP_
 
 
#include <complex>
#include <functional>
#include <map>
#include <string>
#include <unordered_map>
#include <utility>
 
#include <ginkgo/core/base/exception_helpers.hpp>
#include <ginkgo/core/base/lin_op.hpp>
#include <ginkgo/core/base/types.hpp>
#include <ginkgo/core/base/utils_helper.hpp>
#include <ginkgo/core/config/property_tree.hpp>
#include <ginkgo/core/stop/criterion.hpp>
 
 
namespace gko {
namespace config {
 
 
class registry;
 
class type_descriptor;
 
using configuration_map =
    std::map<std::string,
             std::function<deferred_factory_parameter<gko::LinOpFactory>(
                 const pnode&, const registry&, type_descriptor)>>;
 
 
namespace detail {
 
 
class registry_accessor;
 
 
template <typename T, typename = void>
struct base_type {};
 
template <typename T>
struct base_type<T, std::enable_if_t<std::is_convertible<T*, LinOp*>::value>> {
    using type = LinOp;
};
 
template <typename T>
struct base_type<
    T, std::enable_if_t<std::is_convertible<T*, LinOpFactory*>::value>> {
    using type = LinOpFactory;
};
 
template <typename T>
struct base_type<
    T,
    std::enable_if_t<std::is_convertible<T*, stop::CriterionFactory*>::value>> {
    using type = stop::CriterionFactory;
};
 
 
class allowed_ptr {
public:
    template <typename Type>
    allowed_ptr(std::shared_ptr<Type> obj);
 
    template <typename Type>
    bool contains() const;
 
    template <typename Type>
    std::shared_ptr<Type> get() const;
 
private:
    struct generic_container {
        virtual ~generic_container() = default;
    };
 
    template <typename Type>
    struct concrete_container : generic_container {
        concrete_container(std::shared_ptr<Type> obj) : ptr{obj}
        {
            static_assert(
                std::is_same<Type, typename base_type<Type>::type>::value,
                "The given type must be a base_type");
        }
 
        std::shared_ptr<Type> ptr;
    };
 
    std::shared_ptr<generic_container> data_;
};
 
 
template <typename Type>
inline allowed_ptr::allowed_ptr(std::shared_ptr<Type> obj)
{
    data_ =
        std::make_shared<concrete_container<typename base_type<Type>::type>>(
            obj);
}
 
 
template <typename Type>
inline bool allowed_ptr::contains() const
{
    return dynamic_cast<const concrete_container<Type>*>(data_.get());
}
 
 
template <typename Type>
inline std::shared_ptr<Type> allowed_ptr::get() const
{
    GKO_THROW_IF_INVALID(this->template contains<Type>(),
                         "does not hold the requested type.");
    return dynamic_cast<concrete_container<Type>*>(data_.get())->ptr;
}
 
 
}  // namespace detail
 
 
class registry final {
public:
    friend class detail::registry_accessor;
 
 
    registry(const configuration_map& additional_map = {});
 
    registry(
        const std::unordered_map<std::string, detail::allowed_ptr>& stored_map,
        const configuration_map& additional_map = {});
 
    template <typename T>
    bool emplace(std::string key, std::shared_ptr<T> data);
 
protected:
    template <typename T>
    std::shared_ptr<T> get_data(std::string key) const;
 
    const configuration_map& get_build_map() const { return build_map_; }
 
private:
    std::unordered_map<std::string, detail::allowed_ptr> stored_map_;
    configuration_map build_map_;
};
 
 
template <typename T>
inline bool registry::emplace(std::string key, std::shared_ptr<T> data)
{
    auto it = stored_map_.emplace(key, data);
    return it.second;
}
 
 
template <typename T>
inline std::shared_ptr<T> registry::get_data(std::string key) const
{
    return gko::as<T>(stored_map_.at(key)
                          .template get<typename detail::base_type<T>::type>());
}
 
}  // namespace config
}  // namespace gko
 
#endif  // GKO_PUBLIC_CORE_CONFIG_REGISTRY_HPP_