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::vector<std::shared_ptr<GenericManagingModule<T>>>
        createAllSelectedManagingModules(
            SimulationClassBase<T>* sim_pointer,
            const std::vector<std::string>& list_of_mananging_modules_to_load);
        static std::vector<std::shared_ptr<GenericSubmodule<T>>> createAllSelectedSubmodules(
            SimulationClassBase<T>* sim_pointer,
            const std::vector<std::shared_ptr<GenericManagingModule<T>>>& loaded_managing_modules);
        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;
}
 
template <typename T>
std::vector<std::shared_ptr<GenericManagingModule<T>>>
ModuleFactory<T>::createAllSelectedManagingModules(
    SimulationClassBase<T>* sim_pointer,
    const std::vector<std::string>& list_of_mananging_modules_to_load)
{
    std::unordered_set<std::string> modules_to_load_set(list_of_mananging_modules_to_load.begin(),
                                                        list_of_mananging_modules_to_load.end());
    std::vector<std::shared_ptr<GenericManagingModule<T>>> all_loaded_modules{};
 
    for (auto& [key, module] : m_registry)
    {
        if (modules_to_load_set.contains(key))
        {
            all_loaded_modules.emplace_back(module(sim_pointer));
        }
    }
    return all_loaded_modules;
}
 
template <typename T>
std::vector<std::shared_ptr<GenericSubmodule<T>>> ModuleFactory<T>::createAllSelectedSubmodules(
    SimulationClassBase<T>* sim_pointer,
    const std::vector<std::shared_ptr<GenericManagingModule<T>>>& loaded_managing_modules)
{
    std::vector<std::shared_ptr<GenericSubmodule<T>>> all_loaded_submodules{};
 
    std::unordered_set<std::string> unique_submodule_names_set;
 
    for (auto const& module_pointer : loaded_managing_modules)
    {
        for (auto const& submodule_name : module_pointer->getSubmoduleList())
        {
            all_loaded_submodules.emplace_back(m_registry_submodules[submodule_name](sim_pointer));
            unique_submodule_names_set.insert(submodule_name);
        }
    }
 
    std::vector<std::string> last_added_submodules(unique_submodule_names_set.begin(),
                                                   unique_submodule_names_set.end());
 
    // Check iteratively the sub-submodules to complete the loaded submodules list.
    while (!last_added_submodules.empty())
    {
        std::vector<std::string> newly_added;
        for (auto& submodule_pointer : all_loaded_submodules)
        {
            std::string submodule_name{submodule_pointer->getNameLocal()};
            if (unique_submodule_names_set.contains(submodule_name))
            {
                for (auto& submodule_name : submodule_pointer->getSubmoduleList())
                {
                    if (unique_submodule_names_set.insert(submodule_name).second)
                    {
                        newly_added.push_back(submodule_name);
                        all_loaded_submodules.emplace_back(
                            m_registry_submodules[submodule_name](sim_pointer));
                    }
                }
            }
        }
        last_added_submodules.swap(newly_added);
    }
 
    return all_loaded_submodules;
}
#endif