persistentRepoAdapter.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_PERSISTENTREPOADAPTER_HPP
#define RTCTK_COMPONENTFRAMEWORK_PERSISTENTREPOADAPTER_HPP
 
#include <atomic>
#include <string>
#include <typeindex>
#include <typeinfo>
#include <utility>
 
#include <mal/utility/Uri.hpp>
 
#include <rtctk/componentFramework/dynamicThreadPool.hpp>
#include <rtctk/componentFramework/exceptions.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/pathMapper.hpp>
#include <rtctk/componentFramework/persistentRepoIf.hpp>
#include <rtctk/componentFramework/requestDispatcher.hpp>
 
namespace rtctk::componentFramework {

class RTCTK_API PersistentRepoAdapter : public PersistentRepoIf {
public:
    inline static const std::string SUPPORTED_URI_SCHEME = "cii.config";

    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 GetUri() const override {
        return m_path_mapper.GetBaseUri();
    }
 
    ~PersistentRepoAdapter() override = default;

    uint64_t GetFitsWriteThreshold() const {
        return m_fits_write_threshold;
    }

    void SetFitsWriteThreshold(uint64_t value) {
        m_fits_write_threshold = value;
    }
 
private:
    template <typename T>
    void CreateImpl(detail::CreateRequest<T>& request);
 
    template <typename T>
    void ReadImpl(detail::ReadRequest<T>& request);
 
    template <typename T>
    void WriteImpl(detail::WriteRequest<T>& request);
 
    template <typename T>
    void PartialReadImpl(detail::PartialReadRequest<T>& request);
 
    template <typename T>
    void PartialWriteImpl(detail::PartialWriteRequest<T>& request);
 
    void ReadMetaDataImpl(detail::ReadMetaDataRequest& request);
    void WriteMetaDataImpl(detail::WriteMetaDataRequest& request);
    void DeleteImpl(detail::DeleteRequest& request);
    void ExistsImpl(detail::ExistsRequest& request);
    void GetChildrenImpl(detail::GetChildrenRequest& request);
    void CreateLinkImpl(detail::CreateSymlinkRequest& request);
    void UpdateLinkImpl(detail::UpdateSymlinkRequest& request);
 
    BatchResponse ProcessRequests(const RequestList& requests) override;
 
    void GetChildren(const DataPointPath& path, PathList& datapoints, PathList& childpaths) const;

    void FillExtraMetadata(MetaData& metadata, const DataPointPath& path);

    template <typename T>
    static void CheckBufferAndDataPointTypesMatch(const std::type_info& type, const T* node);
 
    log4cplus::Logger& m_logger;

    std::atomic<uint64_t> m_fits_write_threshold;

    PathMapper m_path_mapper;

    DynamicThreadPool m_thread_pool{"psr_worker"};
 
    RTCTK_LOCAL static const std::type_info& LookupCppType(const std::string& tag);
    RTCTK_LOCAL static std::string LookupYamlTag(const MetaData& metadata);
 
    RTCTK_LOCAL static std::tuple<std::string, std::string, bool>
    LookupYamlTags(const MetaData& metadata);
 
    using TagToTypeMap = std::unordered_map<std::string, const std::type_info&>;
    using TypeToTagMap = std::unordered_map<std::type_index, std::pair<std::string, std::string>>;

    static const TagToTypeMap S_TAG_TO_TYPE;

    static const TypeToTagMap S_TYPE_TO_TAG;
 
    template <typename T>
    static RequestDispatcher<PersistentRepoAdapter>::TableEntries BindTypeHandlers();
 
    static const RequestDispatcher<PersistentRepoAdapter> S_REQUEST_DISPATCHER;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_PERSISTENTREPOADAPTER_HPP