persistentRepoAdapter.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_PERSISTENTREPOADAPTER_HPP
#define RTCTK_COMPONENTFRAMEWORK_PERSISTENTREPOADAPTER_HPP
 
#include <atomic>
#include <memory>
#include <mutex>
#include <string>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
 
#include <mal/utility/Uri.hpp>
 
#include <rtctk/componentFramework/exceptions.hpp>
#include <rtctk/componentFramework/fileRepository.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/pathMapper.hpp>
#include <rtctk/componentFramework/persistentRepoIf.hpp>
 
namespace rtctk::componentFramework {
 
class PersistentRepoAdapter : public PersistentRepoIf {
public:
    inline static const std::string SUPPORTED_URI_SCHEME = "cii.config";
 
    class ServiceFailureException : public RtctkException {
    public:
        explicit ServiceFailureException(const DataPointPath& path);
    };
 
    class InvalidDocumentException : public RtctkException {
    public:
        explicit InvalidDocumentException(const DataPointPath& path, const elt::mal::Uri& uri);
        explicit InvalidDocumentException(const DataPointPath& path,
                                          const elt::mal::Uri& uri,
                                          const std::string& message);
    };
 
    class PathMissingException : public RtctkException {
    public:
        explicit PathMissingException(const DataPointPath& path);
    };
 
    PersistentRepoAdapter() = delete;
 
    PersistentRepoAdapter(const PersistentRepoAdapter&) = delete;
 
    PersistentRepoAdapter& operator=(const PersistentRepoAdapter&) = delete;
 
    PersistentRepoAdapter(PersistentRepoAdapter&&) = default;
 
    PersistentRepoAdapter& operator=(PersistentRepoAdapter&&) = default;
 
    explicit PersistentRepoAdapter(const elt::mal::Uri& baseuri, bool simple_layout = false);
 
    elt::mal::Uri GetBaseUri() const {
        return m_path_mapper.GetBaseUri();
    }
 
    virtual ~PersistentRepoAdapter() = default;
 
    using RepositoryIf::CreateDataPoint;
    void CreateDataPoint(const DataPointPath& path, const std::type_info& type) override;
 
    void DeleteDataPoint(const DataPointPath& path) override;
    const std::type_info& GetDataPointType(const DataPointPath& path) const override;
    std::size_t GetDataPointSize(const DataPointPath& path) const override;
    bool DataPointExists(const DataPointPath& path) const override;
    std::pair<PathList, PathList> GetChildren(const DataPointPath& path) const override;
    Response SendReadRequest(const ReadRequest& request) const override;
    Response SendWriteRequest(const WriteRequest& request) override;
 
    std::uint64_t GetFitsWriteThreshold() const {
        return m_fits_write_threshold;
    }
 
    void SetFitsWriteThreshold(std::uint64_t value) {
        m_fits_write_threshold = value;
    }
 
private:
    template <typename R, typename F>
    Response ProcessRequest(const R& request, F dispatch) const;
 
    template <typename T>
    static void CheckBufferAndDataPointTypesMatch(const std::type_info& type, const T* node);
 
    class IoFunctions {
    public:
        virtual ~IoFunctions() = default;
        virtual void
        CreateDataPoint(const PersistentRepoAdapter* repo, const DataPointPath& path) const = 0;
        virtual void ReadDataPoint(const PersistentRepoAdapter* repo,
                                   const DataPointPath& path,
                                   void* buffer) const = 0;
        virtual void WriteDataPoint(const PersistentRepoAdapter* repo,
                                    const DataPointPath& path,
                                    const void* buffer) const = 0;
    };
 
    template <typename T>
    class IoFunctionsImpl : public IoFunctions {
    public:
        IoFunctionsImpl(const std::string& yaml_type) : m_yaml_type(yaml_type){};
        virtual ~IoFunctionsImpl() = default;
        void CreateDataPoint(const PersistentRepoAdapter* repo,
                             const DataPointPath& path) const override;
        void ReadDataPoint(const PersistentRepoAdapter* repo,
                           const DataPointPath& path,
                           void* buffer) const override;
        void WriteDataPoint(const PersistentRepoAdapter* repo,
                            const DataPointPath& path,
                            const void* buffer) const override;
 
    private:
        std::string m_yaml_type;
    };
 
    using IoFunctionMap = std::unordered_map<std::type_index, std::shared_ptr<IoFunctions>>;
 
    template <typename T>
    static auto MakeMapEntry(const std::string& yaml_type);
 
    log4cplus::Logger& m_logger;
 
    mutable std::mutex m_mutex;
 
    PathMapper m_path_mapper;
 
    std::atomic<std::uint64_t> m_fits_write_threshold;
 
    using TypeMap = std::unordered_map<std::string, const std::type_info&>;
 
    static const TypeMap S_TYPE_MAP;
 
    static const IoFunctionMap S_IO_FUNCTIONS;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_PERSISTENTREPOADAPTER_HPP