SetupRunner.h

Go to the documentation of this file.

#ifndef TPM_SRC_SETUP_RUNNER
#define TPM_SRC_SETUP_RUNNER
 
#include <memory>
#include <string>
#include <valarray>
 
#include "ChainManager.h"
#include "GenericManagingModule.h"
#include "GenericSubmodule.h"
 
template <typename T>
bool runSetup(std::vector<std::shared_ptr<GenericManagingModule<T>>> all_modules,
              std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules,
              std::unordered_set<std::string> loaded_managing_modules)
{
    std::unordered_set<std::string> loaded_submodules{
        getLoadedSubmodules(all_modules, all_submodules, loaded_managing_modules)};
 
    for (const auto& module : all_modules)
    {
        std::string module_name{module->getNameLocal()};
        if (loaded_managing_modules.contains(module_name) || loaded_managing_modules.empty())
        {
            module->setup(all_submodules);
        }
    }
 
    // Since layering of submodules is allowed, all submodules also need the complete submodule list
    for (const auto& submodule : all_submodules)
    {
        std::string submodule_name{submodule->getNameLocal()};
        if (loaded_submodules.contains(submodule_name) || loaded_managing_modules.empty())
        {
            submodule->setup(all_submodules);
        }
    }
 
    return true;
}
 
template <typename T>
std::unordered_set<std::string> getLoadedSubmodules(
    std::vector<std::shared_ptr<GenericManagingModule<T>>> all_modules,
    std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules,
    std::unordered_set<std::string> loaded_managing_modules)
{
    std::unordered_set<std::string> unique_submodule_names_set;
 
    for (auto const& module_pointer : all_modules)
    {
        std::string module_name{module_pointer->getNameLocal()};
        if (loaded_managing_modules.contains(module_name))
        {
            for (auto const& submodule_name : module_pointer->getSubmoduleList())
            {
                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_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);
                    }
                }
            }
        }
        last_added_submodules.swap(newly_added);
    }
 
    return unique_submodule_names_set;
}
 
#endif