populateConfig.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_POPULATECONFIG_HPP
#define RTCTK_COMPONENTFRAMEWORK_POPULATECONFIG_HPP
 
#include <functional>
#include <map>
#include <optional>
#include <typeindex>
 
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/persistentRepoIf.hpp>
#include <rtctk/componentFramework/runtimeRepoIf.hpp>
#include <rtctk/componentFramework/serverAliasCache.hpp>
#include <rtctk/componentFramework/stopToken.hpp>
 
namespace rtctk::componentFramework {
 
class PopulateConfig {
public:
    class RepositoryServiceException : public RtctkException {
    public:
        // using RtctkException::RtctkException;
 
        explicit RepositoryServiceException(const std::string& repository);
    };
 
    class InvalidConfigException : public RtctkException {
    public:
        using RtctkException::RtctkException;
        explicit InvalidConfigException(const std::vector<std::string>& errors);
    };
 
    class InvalidDataPointException : public RtctkException {
    public:
        explicit InvalidDataPointException(const DataPointPath& path,
                                           const std::string& explanation = "");
    };
 
    PopulateConfig() = delete;
 
    PopulateConfig(const PopulateConfig&) = delete;
 
    PopulateConfig& operator=(const PopulateConfig&) = delete;
 
    PopulateConfig(PopulateConfig&&) = default;
 
    PopulateConfig& operator=(PopulateConfig&&) = default;
 
    PopulateConfig(PersistentRepoIf& source, RuntimeRepoIf& target);
 
    bool IsDisablePopulateFlagSet(const std::string& rtc_supervisor);
 
    bool IsDisableValidateFlagSet(const std::string& rtc_supervisor);
 
    void ValidatePersistentRepository() const;
 
    void ClearConfig();
 
    void PrePopulateConfig(const std::string& active_deployment_set);
 
    void PopulateRuntimeRepo(StopToken stop_token,
                             const std::map<std::string, std::string>& requested_modes);
 
    void CopyActiveDeploymentSet();
 
    std::multimap<std::string, std::string> GetAvailableModes() const;
 
    std::map<std::string, std::string> GetDefaultModes() const;
 
    std::map<std::string, std::string> GetActiveModes();
 
    void ValidateRequestedModes(const std::map<std::string, std::string>& requested_modes) const;
 
    void CopyRequestedModes(const std::map<std::string, std::string>& requested_modes);
 
    void CopyHierarchy(const DataPointPath& source, const DataPointPath& target);
 
    void CopyDataPoint(const DataPointPath& source, const DataPointPath& target);
 
    void ValidateWriteBack(const std::vector<DataPointPath>& datapoints);
 
    void WriteBack(StopToken stop, const std::vector<DataPointPath>& datapoints);
 
private:
    void SetActiveModes(const std::map<std::string, std::string>& active_modes);
    DataPointPath GetActiveDeploymentPath() const;
    void CopyDefaults(const DataPointPath& active_deployment_path);
    void CopyModes(const DataPointPath& active_deployment_path);
    void PopulateServerAliasCache(const DataPointPath& defaults_path);
    void DeleteHierarchy(const DataPointPath& path);
    void ComputeParameterMappings();
    void WriteBackDataPoint(const DataPointPath& source, const DataPointPath& target);
 
    log4cplus::Logger& m_logger;
 
    PersistentRepoIf& m_persistent_repo;
 
    RuntimeRepoIf& m_runtime_repo;
 
    struct IoFunctionMapEntry {
        using CopyFunction = std::function<void(const PersistentRepoIf&,
                                                const DataPointPath&,
                                                RuntimeRepoIf&,
                                                const DataPointPath&,
                                                const std::string& server_alias)>;
 
        using WriteBackFunction = std::function<void(
            const RuntimeRepoIf&, const DataPointPath&, PersistentRepoIf&, const DataPointPath&)>;
 
        CopyFunction m_copy_function;
        WriteBackFunction m_writeback_function;
    };
 
    using IoFunctionMap = std::map<std::type_index, IoFunctionMapEntry>;
 
    template <typename T>
    static auto MakeMapEntry();
 
    static const IoFunctionMap S_IO_FUNCTIONS;
 
    ServerAliasCache m_server_alias_cache;
 
    std::map<DataPointPath, DataPointPath> m_psr_to_rtr_map;
    std::map<DataPointPath, DataPointPath> m_rtr_to_psr_map;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_POPULATECONFIG_HPP