Factory.H

Go to the documentation of this file.

#ifndef FACTORY_H
#define FACTORY_H
 
#include <memory>
#include <unordered_map>
#include <iostream>
 
#include "AMReX_Print.H"
#include "AMReX.H"
 
namespace amr_wind {
 
template <class Base, class... Args>
struct Factory
{
    static std::unique_ptr<Base> create(const std::string& key, Args... args)
    {
        key_exists_or_error(key);
        auto ptr = table().at(key)(std::forward<Args>(args)...);
        amrex::Print() << "Creating " << Base::base_identifier()
                       << " instance: " << key << std::endl;
        return ptr;
    }
    static std::unique_ptr<Base> create(const std::string& key, Args... args) {…}
 
    static void print(std::ostream& os)
    {
        const auto& tbl = table();
        os << Base::base_identifier() << " " << tbl.size() << std::endl;
        for (const auto& it : tbl) {
            os << " - " << it.first << std::endl;
        }
    }
    static void print(std::ostream& os) {…}
 
    template <class T>
    struct Register : public Base
    {
        friend T;
        static bool registered;
 
        static bool add_sub_type()
        {
            // TODO: Add checks against multiple registration
            Factory::table()[T::identifier()] =
                [](Args... args) -> std::unique_ptr<Base> {
                return std::unique_ptr<Base>(
                    new T(std::forward<Args>(args)...));
            };
            return true;
        }
        static bool add_sub_type() {…}
 
        ~Register() override
        {
            if (registered) {
                const auto& tbl = Factory::table();
                const auto it = tbl.find(T::identifier());
                registered = (it != tbl.end());
            }
        }
        ~Register() override {…}
 
    private:
        Register() { (void)registered; }
    };
    struct Register : public Base {…};
 
    virtual ~Factory() = default;
    friend Base;
 
private:
    using CreatorFunc = std::unique_ptr<Base> (*)(Args...);
    using LookupTable = std::unordered_map<std::string, CreatorFunc>;
 
    static void key_exists_or_error(const std::string& key)
    {
        const auto& tbl = table();
        if (tbl.find(key) == tbl.end()) {
            // Print valid options
            if (amrex::ParallelDescriptor::IOProcessor()) {
                print(std::cout);
            }
            // Quit with error
            amrex::Abort(
                "In " + Base::base_identifier() +
                " cannot find instance: " + key);
        }
    }
    static void key_exists_or_error(const std::string& key) {…}
 
    static LookupTable& table()
    {
        static LookupTable tbl;
        return tbl;
    }
    static LookupTable& table() {…}
 
    Factory() = default;
};
struct Factory {…};
 
template <class Base, class... Args>
template <class T>
bool Factory<Base, Args...>::Register<T>::registered =
    Factory<Base, Args...>::Register<T>::add_sub_type();
 
} // namespace amr_wind
 
#endif /* FACTORY_H */