StaticModuleContainer.h

Go to the documentation of this file.

#ifndef STATIC_MODULE_CONTAINER_H
#define STATIC_MODULE_CONTAINER_H
 
#include <exception>
#include <memory>
#include <string>
 
#include "GenericManagingModule.h"
#include "GenericSubmodule.h"
#include "ModuleFactory.h"
#include "SimulationClassBase.h"
 
template <typename T>
class StaticModuleContainer
{
    private:
        static inline std::vector<std::shared_ptr<GenericManagingModule<T>>> m_all_modules{};
        static inline std::vector<std::shared_ptr<GenericSubmodule<T>>> m_all_submodules{};
 
        // Since this is a static container, this variable denotes whether the modules are created
        // or the vector is empty
        static inline bool m_modules_created{false};
 
    public:
        StaticModuleContainer(SimulationClassBase<T>* sim_ptr)
        {
            try
            {
                m_all_modules = ModuleFactory<T>::createAllSelectedManagingModules(
                    sim_ptr,
                    sim_ptr->m_simulation_config.getStringVectorParameters("managing_modules"));
            }
            catch (const BadInput&)
            {
                m_all_modules = ModuleFactory<T>::createAllManagingModules(sim_ptr);
            }
            m_all_submodules =
                ModuleFactory<T>::createAllSelectedSubmodules(sim_ptr, m_all_modules);
            m_modules_created = true;
        }
 
        static bool isInitialized() { return m_modules_created; }
 
        static std::vector<std::shared_ptr<GenericManagingModule<T>>>&
        getAllSelectedManagingModules()
        {
            return m_all_modules;
        }
 
        static std::vector<std::shared_ptr<GenericSubmodule<T>>>& getAllSelectedSubmodules()
        {
            return m_all_submodules;
        }
 
        static std::shared_ptr<GenericManagingModule<T>> getSelectedManagingModule(
            const std::string& key)
        {
            for (auto& module_ptr : m_all_modules)
            {
                if (key == module_ptr->getNameLocal())
                {
                    return module_ptr;
                }
            }
            std::cerr << "[StaticModuleContainer]: Requested managing module is not loaded, please "
                         "make sure it was loaded!\n";
            throw std::runtime_error(static_cast<std::string>(
                "[StaticModuleContainer]: Requested managing module is not loaded, please make "
                "sure it was loaded!"));
        }
 
        static std::shared_ptr<GenericSubmodule<T>> getSelectedSubmodule(const std::string& key)
        {
            for (auto& submodule_ptr : m_all_submodules)
            {
                if (key == submodule_ptr->getNameLocal())
                {
                    return submodule_ptr;
                }
            }
            std::cerr << "[StaticModuleContainer]: Requested submodule is not loaded, please make "
                         "sure it was loaded!\n";
            throw std::runtime_error(static_cast<std::string>(
                "[StaticModuleContainer]: Requested submodule is not loaded, please make sure it "
                "was loaded!"));
        }
};
#endif