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/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,
                            bool allow_non_dynamic_mode_options = false);

    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 DeleteHierarchy(const DataPointPath& path);
    void ComputeParameterMappings();
    void WriteBackDataPoint(const DataPointPath& source, const DataPointPath& target);
    void EnsureModeHierarchyIsDynamic(const DataPointPath&);
 
    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&)>;
 
        using WriteBackFunction = std::function<void(
            const RuntimeRepoIf&, const DataPointPath&, PersistentRepoIf&, const DataPointPath&)>;
 
        CopyFunction m_copy_function;
        WriteBackFunction m_writeback_function;
    };
 
    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