parameterizedobject.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#ifndef DUNE_COMMON_PARAMETERIZEDOBJECT_HH
#define DUNE_COMMON_PARAMETERIZEDOBJECT_HH
 
#include <functional>
#include <map>
#include <memory>
 
#include <dune/common/exceptions.hh>
#include <dune/common/typeutilities.hh>
#include <dune/common/rangeutilities.hh>
 
namespace Dune {
 
template<typename Signature,
         typename KeyT = std::string>
class ParameterizedObjectFactory;
 
template<typename TypeT,
         typename KeyT,
         typename... Args>
class ParameterizedObjectFactory<TypeT(Args...), KeyT>
{
    public:
 
        typedef KeyT Key;
 
        using Type = TypeT;
 
    protected:
 
        using Creator = std::function<Type(Args...)>;
 
        template<class F>
        static constexpr auto has_proper_signature(Dune::PriorityTag<1>)
            -> decltype( std::declval<F>()(std::declval<Args>()...), std::true_type())
        {
            return {};
        }
 
        template<class F>
        static constexpr std::false_type has_proper_signature(Dune::PriorityTag<0>)
        {
            return {};
        }
 
    public:
 
        Type create(Key const& key, Args ... args) const {
            typename Registry::const_iterator i = registry_.find(key);
            if (i == registry_.end()) {
                DUNE_THROW(Dune::InvalidStateException,
                    "ParametrizedObjectFactory: key ``" <<
                    key << "'' not registered");
            }
            else return i->second(args...);
        }
 
        template<class Impl>
        void define(Key const& key)
        {
            registry_[key] = DefaultCreator<Impl>();
        }
 
        template<class F,
            typename std::enable_if<has_proper_signature<F>(PriorityTag<42>()), int>::type = 0>
        void define(Key const& key, F&& f)
        {
            registry_[key] = f;
        }
 
        template<class Impl,
            typename std::enable_if<
                std::is_convertible<Impl, Type>::value
                and not std::is_convertible<Impl, Creator>::value,
                int>::type = 0>
        void define(Key const& key, Impl&& t)
        {
            registry_[key] = [=](Args...) { return t;};
        }
 
        bool contains(Key const& key) const
        {
            return registry_.count(key);
        }
 
        auto keys() const {
            return transformedRangeView(registry_, [](const auto & entry) { return entry.first; } );
        }
 
    private:
 
        template<class T>
        struct Tag{};
 
        template<class Impl>
        struct DefaultCreator
        {
            template<class...  T>
            Type operator()(T&&... args) const
            {
                return DefaultCreator::create(Tag<Type>(), PriorityTag<42>(), std::forward<T>(args)...);
            }
 
            template<class Target, class... T>
            static Type create(Tag<Target>, PriorityTag<1>, T&& ... args) {
                return Impl(std::forward<T>(args)...);
            }
 
            template<class Target, class... T>
            static Type create(Tag<std::unique_ptr<Target>>, PriorityTag<2>, T&& ... args) {
                return std::make_unique<Impl>(std::forward<T>(args)...);
            }
 
            template<class Target, class... T>
            static Type create(Tag<std::shared_ptr<Target>>, PriorityTag<3>, T&& ... args) {
                return std::make_shared<Impl>(std::forward<T>(args)...);
            }
 
        };
 
        typedef std::map<Key, Creator> Registry;
        Registry registry_;
};
 
 
 
} // end namespace Dune
 
#endif // DUNE_COMMON_PARAMETERIZEDOBJECT_HH