runtimeSelectionFactory.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 - 2025 NeoN authors
// SPDX-FileCopyrightText: 2023 AMR Wind Authors
//
// SPDX-License-Identifier: MIT
 
// ##############################################################################
// # Original design taken from amr wind                                        #
// # from here                                                                  #
// # https://github.com/Exawind/amr-wind/blob/v2.1.0/amr-wind/core/Factory.H    #
// ##############################################################################
// its quite tricky for multiple compilers that bool REGISTERED gets initialized
// the static_assert helps to register the class
// https://stackoverflow.com/questions/6420985/
// how-to-force-a-static-member-to-be-initialized?noredirect=1&lq=1
#pragma once
 
#include <memory>
#include <unordered_map>
#include <iostream>
#include <functional>
 
#include "error.hpp"
 
namespace NeoN
{
 
class BaseClassData
{
public:
 
    std::function<std::string(const std::string&)>
        doc; 
    std::function<std::string(const std::string&)>
        schema; 
    std::function<std::vector<std::string>()>
        entries; 
};
 
class BaseClassDocumentation
{
public:
 
    using LookupTable = std::unordered_map<std::string, BaseClassData>;
 
    static void registerClass(std::string name, BaseClassData data)
    {
        // if not already registered
        docTable()[name] = data;
    }
 
    static std::string doc(const std::string& baseClassName, const std::string& derivedClassName)
    {
        return docTable().at(baseClassName).doc(derivedClassName);
    }
 
    static std::string schema(const std::string& baseClassName, const std::string& derivedClassName)
    {
        // get the schema of the derived class
        return docTable().at(baseClassName).schema(derivedClassName);
    }
 
    static std::vector<std::string> entries(const std::string& baseClassName)
    {
        return docTable().at(baseClassName).entries();
    }
 
    static LookupTable& docTable()
    {
        static LookupTable tbl;
        return tbl;
    }
};
 
 
template<class baseClass>
struct RegisterDocumentation
{
    RegisterDocumentation()
    {
        // avoid unused variable warning
        // is required to instantiate the static variable and with it the registration
        (void)REGISTERED;
    }
 
    static bool init()
    {
        BaseClassData data = {baseClass::doc, baseClass::schema, baseClass::entries};
        BaseClassDocumentation::registerClass(baseClass::name(), data);
        return true;
    }
 
    static bool REGISTERED; 
#ifdef _MSC_VER
    static_assert((bool)&REGISTERED);
#endif
};
 
// Initialize the static variable and register the class
template<class baseClass>
bool RegisterDocumentation<baseClass>::REGISTERED = RegisterDocumentation<baseClass>::init();
 
class DerivedClassDocumentation
{
public:
 
    std::function<std::string()> doc;
    std::function<std::string()> schema;
};
 
// Parameters helper type
template<typename... Args>
struct Parameters
{
};
 
// Primary template declaration
template<typename Base, typename Params>
class RuntimeSelectionFactory;
 
// Partial specialization for Parameters
template<typename Base, typename... Args>
class RuntimeSelectionFactory<Base, Parameters<Args...>> : public RegisterDocumentation<Base>
{
public:
 
    friend Base;
 
    using CreatorFunc = std::function<std::unique_ptr<Base>(Args...)>;
    using LookupTable = std::unordered_map<std::string, CreatorFunc>;
    using ClassDocTable = std::unordered_map<std::string, DerivedClassDocumentation>;
 
    static std::string doc(const std::string& derivedClassName)
    {
        // get the documentation of the derived class
        return docTable().at(derivedClassName).doc();
    }
 
    static std::string schema(const std::string& derivedClassName)
    {
        // get the schema of the derived class
        return docTable().at(derivedClassName).schema();
    }
 
    static std::vector<std::string> entries()
    {
        std::vector<std::string> entries;
        for (const auto& it : table())
        {
            entries.push_back(it.first);
        }
        return entries;
    }
 
 
    static std::unique_ptr<Base> create(const std::string& key, Args... args)
    {
        keyExistsOrError(key);
        auto ptr = table().at(key)(std::forward<Args>(args)...);
        return ptr;
    }
 
 
    static void print(std::ostream& os)
    {
        const auto& tbl = table();
        os << Base::name() << " " << tbl.size() << std::endl;
        for (const auto& it : tbl)
        {
            os << " - " << it.first << std::endl;
        }
    }
 
    template<class derivedClass>
    class Register : public Base
    {
    public:
 
        using Base::Base;
 
        friend derivedClass;
        [[maybe_unused]] static bool REGISTERED;
#ifdef _MSC_VER
        static_assert((bool)&REGISTERED);
#endif
 
        static bool addSubType()
        {
            CreatorFunc func = [](Args... args) -> std::unique_ptr<Base> {
                return static_cast<std::unique_ptr<Base>>(new derivedClass(std::forward<Args>(args
                )...));
            };
            RuntimeSelectionFactory::table()[derivedClass::name()] = func;
 
            DerivedClassDocumentation childData;
            childData.doc = []() -> std::string { return derivedClass::doc(); };
            childData.schema = []() -> std::string { return derivedClass::schema(); };
            RuntimeSelectionFactory::docTable()[derivedClass::name()] = childData;
 
            return true;
        }
 
        ~Register() override
        {
            if (REGISTERED)
            {
                const auto& tbl = RuntimeSelectionFactory::table();
                const auto it = tbl.find(derivedClass::name());
                REGISTERED = (it != tbl.end());
            }
        }
 
#ifdef _MSC_VER
    private:
 
        Register() { (void)REGISTERED; }
#endif
    };
 
    virtual ~RuntimeSelectionFactory() = default;
 
    static std::size_t size() { return table().size(); }
 
    static LookupTable& table()
    {
        static LookupTable tbl;
        return tbl;
    }
 
    static ClassDocTable& docTable()
    {
        static ClassDocTable tbl;
        return tbl;
    }
 
private:
 
 
    static void keyExistsOrError(const std::string& name)
    {
        const auto& tbl = table();
        if (tbl.find(name) == tbl.end())
        {
            auto msg = std::string {" Could not find constructor for "} + name + "\n";
            msg += "valid constructors are: \n";
            for (const auto& it : tbl)
            {
                msg += " - " + it.first + "\n";
            }
            NF_ERROR_EXIT(msg);
        }
    }
 
    RuntimeSelectionFactory() = default;
};
 
// Initialize the static variable and register the class
template<class Base, class... Args>
template<class derivedClass>
bool RuntimeSelectionFactory<Base, Parameters<Args...>>::Register<derivedClass>::REGISTERED =
    RuntimeSelectionFactory<Base, Parameters<Args...>>::template Register<derivedClass>::addSubType(
    );
 
}; // namespace NeoN