ChainManager.h

Go to the documentation of this file.

#ifndef CHAIN_MANAGER_H
#define CHAIN_MANAGER_H
 
#include <algorithm>
#include <concepts>
#include <iostream>
#include <map>
#include <memory>
#include <sstream>
#include <string>
#include <unordered_set>
#include <vector>
 
template <typename ModuleType>
 
    requires requires(const ModuleType& module) {
        module.getNameLocal();  // Checks if getNameLocal() exists and is callable
        {
            module.getNameLocal()
        } -> std::constructible_from<std::string>;  // Checks the return type
    }
 
class DependencyError : public std::exception
{
    private:
        std::string m_error_string;
 
    public:
        DependencyError(
            const std::vector<std::shared_ptr<ModuleType>> unresolved_dependency_modules)
        {
            std::ostringstream oss;
            oss << "[ChainManager]: Failed to resolve dependencies for the following modules:\n";
            for (auto& module : unresolved_dependency_modules)
            {
                oss << module->getNameLocal() << "\n";
            }
            oss << "Please check the dependencies and resolve the circular or missing "
                   "dependencies.\n";
            m_error_string = oss.str();
        }
 
        [[nodiscard]] const char* what() const noexcept override { return m_error_string.c_str(); }
 
        ~DependencyError() override = default;
};
 
template <typename ModuleType>
class ChainManager
{
    private:
        using ModuleList = std::vector<std::shared_ptr<ModuleType>>;
        std::map<std::string_view, ModuleList> m_chain_map{};
 
        bool checkDependencyCurrentModule(std::shared_ptr<ModuleType> module,
                                          ModuleList& sorted_chain_module_vector);
 
    public:
        ChainManager();
        ChainManager(std::string_view chain_type);
 
        void insertModule(std::string_view key, const std::shared_ptr<ModuleType>& module);
 
        void runChain(std::string_view key);
 
        void runSingleModuleInChain(std::string_view chain_key, std::string_view module_key);
 
        void autoLoader(const ModuleList& all_modules);
 
        void autoLoader(const ModuleList& all_modules,
                        const std::vector<std::string>& modules_to_load);
 
        std::vector<std::string> getChainNames() const;
 
        std::unordered_set<std::string> getManagingModuleNames() const;
 
        void resolveDependencies();
};
 
template <typename ModuleType>
ChainManager<ModuleType>::ChainManager()
{
}
 
template <typename ModuleType>
ChainManager<ModuleType>::ChainManager(std::string_view chain_type)
{
    if (chain_type == "global")
    {
        m_chain_map.insert({"InitChain", std::vector<std::shared_ptr<ModuleType>>{}});
        m_chain_map.insert({"PreTimeStepChain", std::vector<std::shared_ptr<ModuleType>>{}});
        m_chain_map.insert({"PostNonLinIterChain", std::vector<std::shared_ptr<ModuleType>>{}});
        m_chain_map.insert({"PostTimeStepChain", std::vector<std::shared_ptr<ModuleType>>{}});
        m_chain_map.insert({"OutputChain", std::vector<std::shared_ptr<ModuleType>>{}});
    }
}
 
template <typename ModuleType>
void ChainManager<ModuleType>::insertModule(std::string_view key,
                                            const std::shared_ptr<ModuleType>& module)
{
    m_chain_map[key].emplace_back(module);
}
 
template <typename ModuleType>
void ChainManager<ModuleType>::runChain(std::string_view key)
{
    // std::cout << "Entered with key: " << key << "\n";
    for (const auto& module_pointer :
         m_chain_map[key])  // m_chain_map[key] is a
                            // std::vector<std::shared_ptr<GenericManagingModule<T>>>
    {
        module_pointer->exec(key);
    }
}
 
template <typename ModuleType>
void ChainManager<ModuleType>::runSingleModuleInChain(std::string_view chain_key,
                                                      std::string_view module_key)
{
    for (const auto& module_pointer :
         m_chain_map[chain_key])  // m_chain_map[key] is a
                                  // std::vector<std::shared_ptr<GenericManagingModule<T>>>
    {
        if (module_pointer->getNameLocal() == module_key)
        {
            module_pointer->exec(chain_key);
        }
    }
}
 
template <typename ModuleType>
void ChainManager<ModuleType>::autoLoader(const ModuleList& all_modules)
{
    for (auto& module : all_modules)
    {
        for (auto& key : module->getChainInsertion())
        {
            insertModule(key, module);
        }
    }
    resolveDependencies();
}
 
template <typename ModuleType>
void ChainManager<ModuleType>::autoLoader(const ModuleList& all_modules,
                                          const std::vector<std::string>& modules_to_load)
{
    std::unordered_set<std::string> modules_to_load_set(modules_to_load.begin(),
                                                        modules_to_load.end());
 
    for (auto& module : all_modules)
    {
        std::string mod_name{module->getNameLocal()};
        if (modules_to_load_set.contains(mod_name))
        {
            for (auto& key : module->getChainInsertion())
            {
                insertModule(key, module);
            }
        }
    }
    resolveDependencies();
}
 
template <typename ModuleType>
void ChainManager<ModuleType>::resolveDependencies()
{
    // Check dependencies for every chain
    for (auto& [key, chain_module_vector] : m_chain_map)
    {
        std::vector<std::shared_ptr<ModuleType>> sorted_chain_module_vector{};
        while (!chain_module_vector.empty())
        {
            bool progress = false;
 
            // Use remove_if to partition the modules: move those with resolved dependencies to the
            // front
            auto current_module = std::remove_if(
                chain_module_vector.begin(), chain_module_vector.end(),
                [&](const auto& module)
                {
                    // If all dependencies are resolved, move this module to the front
                    if (checkDependencyCurrentModule(module, sorted_chain_module_vector))
                    {
                        sorted_chain_module_vector.push_back(module);
                        progress = true;
                        return true;  // Mark it for removal (just shifting it)
                    }
                    return false;  // Keep the module in place
                });
 
            // Erase the modules that were marked for removal (those with unresolved dependencies
            // stay)
            chain_module_vector.erase(current_module, chain_module_vector.end());
 
            // If no progress was made, there are circular or missing dependencies
            if (!progress)
            {
                std::cerr << "[ChainManager]: Failed to resovle all dependencies - terminating "
                             "simulation due to DependencyError!\n";
                throw DependencyError<ModuleType>(chain_module_vector);
            }
        }
        chain_module_vector = std::move(sorted_chain_module_vector);
    }
}
 
template <typename ModuleType>
bool ChainManager<ModuleType>::checkDependencyCurrentModule(std::shared_ptr<ModuleType> module,
                                                            ModuleList& sorted_chain_module_vector)
{
    std::vector<std::string> module_dependencies{module->getDependencies()};
    // If there are no dependencies, the module can always be placed
    if (module_dependencies.empty())
    {
        return true;
    }
 
    std::unordered_set<std::string_view> resolved_names;
    for (const auto& sorted_module : sorted_chain_module_vector)
    {
        resolved_names.insert(sorted_module->getNameLocal());
    }
 
    // Check if all dependencies are resolved
    return std::all_of(module_dependencies.begin(), module_dependencies.end(),
                       [&resolved_names](const std::string& dependency)
                       { return resolved_names.contains(dependency); });
}
 
template <typename ModuleType>
std::vector<std::string> ChainManager<ModuleType>::getChainNames() const
{
    std::vector<std::string> chain_names{};
    chain_names.reserve(m_chain_map.size());
    for (const auto& [key, chain] : m_chain_map)
    {
        chain_names.emplace_back(key);
    }
    return chain_names;
}
 
template <typename ModuleType>
std::unordered_set<std::string> ChainManager<ModuleType>::getManagingModuleNames() const
{
    std::unordered_set<std::string> unique_module_names_set;
    for (auto& [chain_key, chain_module_vector] : m_chain_map)
    {
        for (auto const& module_pointer : chain_module_vector)
        {
            std::string module_name{module_pointer->getNameLocal()};
            unique_module_names_set.insert(module_name);
        }
    }
    return unique_module_names_set;
}
 
#endif