ModuleFactory.h

Go to the documentation of this file.

#ifndef MODULE_FACTORY_H
#define MODULE_FACTORY_H
 
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <unordered_map>
 
#include "GenericManagingModule.h"
#include "GenericSubmodule.h"
#include "SimulationClassBase.h"
 
template <typename T>
class ModuleFactory
{
    public:
        using creation_method =
            std::shared_ptr<GenericManagingModule<T>> (*)(SimulationClassBase<T>* sim);
        using creation_method_submodules =
            std::shared_ptr<GenericSubmodule<T>> (*)(SimulationClassBase<T>* sim);
 
        // No constructor, as only static functions/variables will be used
        ModuleFactory() = delete;
 
        static constexpr bool registerModule(std::string name, creation_method module) noexcept;
        static constexpr bool registerModule(std::string name,
                                             creation_method_submodules module) noexcept;
 
        static std::shared_ptr<GenericManagingModule<T>> create(const std::string& name,
                                                                SimulationClassBase<T>* sim);
        static std::vector<std::shared_ptr<GenericManagingModule<T>>> createAllManagingModules(
            SimulationClassBase<T>* sim_pointer);
        static std::vector<std::shared_ptr<GenericSubmodule<T>>> createAllSubmodules(
            SimulationClassBase<T>* sim_pointer);
        static std::shared_ptr<GenericSubmodule<T>> createSubmodule(const std::string& name,
                                                                    SimulationClassBase<T>* sim);
 
    private:
        static std::unordered_map<std::string, creation_method_submodules> m_registry_submodules;
        static std::unordered_map<std::string, creation_method> m_registry;
};
 
// Declaration of registry variables needed here, because they are static
template <typename T>
std::unordered_map<std::string,
                   std::shared_ptr<GenericManagingModule<T>> (*)(SimulationClassBase<T>* sim)>
    ModuleFactory<T>::m_registry;
 
template <typename T>
std::unordered_map<std::string,
                   std::shared_ptr<GenericSubmodule<T>> (*)(SimulationClassBase<T>* sim)>
    ModuleFactory<T>::m_registry_submodules;
 
template <typename T>
bool constexpr ModuleFactory<T>::registerModule(const std::string name,
                                                creation_method module) noexcept
{
    // If the module is not yet registered, do that and return true
    if (auto current_module = m_registry.find(name); current_module == m_registry.end())
    {
        m_registry.emplace(name, module);
        // Only print this message to the log in release build
        std::cout << "Registering: " << name << "\n";
        return true;
    }
    return false;
}
 
template <typename T>
std::shared_ptr<GenericManagingModule<T>> ModuleFactory<T>::create(const std::string& name,
                                                                   SimulationClassBase<T>* sim)
{
    // If the module was registered, then create it.
    if (auto current_module = m_registry.find(name); current_module != m_registry.end())
    {
        return current_module->second(sim);
    }
    throw std::runtime_error("ModuleFactory: No module registered with name: " + name);
}
 
template <typename T>
bool constexpr ModuleFactory<T>::registerModule(const std::string name,
                                                creation_method_submodules module) noexcept
{
    // If the module is not yet registered, do that and return true
    if (auto current_module = m_registry_submodules.find(name);
        current_module == m_registry_submodules.end())
    {
        m_registry_submodules.emplace(name, module);
        // Only print this message to the log in release build
        std::cout << "Registering submodule: " << name << "\n";
        return true;
    }
    return false;
}
 
template <typename T>
std::shared_ptr<GenericSubmodule<T>> ModuleFactory<T>::createSubmodule(const std::string& name,
                                                                       SimulationClassBase<T>* sim)
{
    // std::cout << "Create submodule " + name + "\n";
    //  If the module was registered, then create it.
    if (auto current_module = m_registry_submodules.find(name);
        current_module != m_registry_submodules.end())
    {
        return current_module->second(sim);
    }
    throw std::runtime_error("ModuleFactory: No module registered with name: " + name);
}
 
template <typename T>
std::vector<std::shared_ptr<GenericManagingModule<T>>> ModuleFactory<T>::createAllManagingModules(
    SimulationClassBase<T>* sim_pointer)
{
    std::vector<std::shared_ptr<GenericManagingModule<T>>> all_loaded_modules{};
 
    all_loaded_modules.reserve(m_registry.size());
    for (auto& [key, module] : m_registry)
    {
        all_loaded_modules.emplace_back(module(sim_pointer));
    }
    return all_loaded_modules;
}
 
template <typename T>
std::vector<std::shared_ptr<GenericSubmodule<T>>> ModuleFactory<T>::createAllSubmodules(
    SimulationClassBase<T>* sim_pointer)
{
    std::vector<std::shared_ptr<GenericSubmodule<T>>> all_loaded_submodules{};
 
    for (auto& [key, submodule] : m_registry_submodules)
    {
        all_loaded_submodules.emplace_back(submodule(sim_pointer));
    }
    return all_loaded_submodules;
}
 
#endif