persistentRepoAdapter.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_PERSISTENTREPOADAPTER_HPP
#define RTCTK_COMPONENTFRAMEWORK_PERSISTENTREPOADAPTER_HPP
 
#include <atomic>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <tuple>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <utility>
 
#include <mal/utility/Uri.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";
 
    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;
 
    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;
 
    mutable std::mutex m_mutex;
 
    PathMapper m_path_mapper;
 
    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