oldbAdapter.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_OLDBADAPTER_HPP
#define RTCTK_COMPONENTFRAMEWORK_OLDBADAPTER_HPP
 
#include <ciiOldb.hpp>
#include <ciiOldbSubscription.hpp>
#include <ciiOldbTypedDataBase.hpp>
 
#include <rtctk/componentFramework/dynamicThreadPool.hpp>
#include <rtctk/componentFramework/oldbIf.hpp>
#include <rtctk/componentFramework/requestDispatcher.hpp>
 
#include <map>
#include <unordered_map>
 
namespace rtctk::componentFramework {

class OldbAdapter : public OldbIf {
public:
    inline static const std::string SUPPORTED_URI_SCHEME = "cii.oldb";

    OldbAdapter() = delete;

    OldbAdapter(const OldbAdapter&) = delete;

    OldbAdapter& operator=(const OldbAdapter&) = delete;

    OldbAdapter(OldbAdapter&&) = delete;
    OldbAdapter& operator=(OldbAdapter&&) = delete;

    explicit OldbAdapter(const elt::mal::Uri& baseuri);

    explicit OldbAdapter(const elt::mal::Uri& baseuri,
                         const std::shared_ptr<elt::oldb::CiiOldb>& oldb);

    ~OldbAdapter() override = default;
 
    elt::mal::Uri GetUri() const override {
        return m_baseuri;
    }
 
protected:
    using CiiOldbTypedDataBase = elt::oldb::CiiOldbTypedDataBase;
    using CiiOldbDpSubscriptionBase = elt::oldb::CiiOldbDpSubscriptionBase;
 
    RTCTK_LOCAL auto GetOldbBaseDataPoint(auto& request);
 
    template <typename CiiType>
    RTCTK_LOCAL auto GetOldbTypedDataPoint(auto& request);
 
    template <typename DataPointType, typename T>
    void CreateImpl(detail::CreateRequest<T>&);
 
    template <typename T>
    void DispatchCreateRequest(detail::CreateRequest<T>&);
 
    template <typename DataPointType, typename T>
    void ReadImpl(detail::ReadRequest<T>&);
 
    template <typename T>
    void DispatchReadRequest(detail::ReadRequest<T>&);
 
    template <typename DataPointType, typename T>
    void WriteImpl(detail::WriteRequest<T>&);
 
    template <typename T>
    void DispatchWriteRequest(detail::WriteRequest<T>&);
 
    template <typename DataPointType, typename T>
    void PartialReadImpl(detail::PartialReadRequest<T>&);
 
    template <typename T>
    void DispatchPartialReadRequest(detail::PartialReadRequest<T>&);
 
    template <typename DataPointType, typename T>
    void PartialWriteImpl(detail::PartialWriteRequest<T>&);
 
    template <typename T>
    void DispatchPartialWriteRequest(detail::PartialWriteRequest<T>&);
 
    template <typename DataPointType>
    void ReadMetaDataImpl(detail::ReadMetaDataRequest&);
 
    void DispatchReadMetaDataRequest(detail::ReadMetaDataRequest&);
 
    template <typename DataPointType>
    void WriteMetaDataImpl(detail::WriteMetaDataRequest&);
 
    void DispatchWriteMetaDataRequest(detail::WriteMetaDataRequest&);
 
    template <typename DataPointType>
    void DeleteWithMetadata(const elt::mal::Uri&);
 
    void DeleteImpl(detail::DeleteRequest&);
    void ExistsImpl(detail::ExistsRequest&);
    void GetChildrenImpl(detail::GetChildrenRequest&);
    void GetChildrenImplRecursive(const DataPointPath&, PathList&, PathList&, bool);
    void CreateLinkImpl(detail::CreateSymlinkRequest&);
    void UpdateLinkImpl(detail::UpdateSymlinkRequest&);
 
    template <typename DataPointType>
    void SubscribeImpl(detail::ValueSubscribeRequest&);
 
    void DispatchSubscribeRequest(detail::ValueSubscribeRequest&);

    void CreateDeleteSubscribeImpl(detail::CreateDeleteSubscribeRequest&);
 
    void UnsubscribeImpl(detail::UnsubscribeRequest&);
 
    BatchResponse ProcessRequests(const RequestList& requests) override;

    const elt::mal::Uri m_baseuri;

    mutable std::shared_ptr<elt::oldb::CiiOldb> m_client;

    mutable std::mutex m_mutex;

    DynamicThreadPool m_thread_pool{"oldb_worker"};
 
    // data structures to hold active subscriptions
    struct SubscriptionEntry {
        std::shared_ptr<CiiOldbTypedDataBase> dp;
        std::shared_ptr<CiiOldbDpSubscriptionBase> sub;
        std::function<void(SubscriptionEntry&)> unreg_cb;
    };
 
    std::map<SubscriptionId, SubscriptionEntry> m_subscriptions;

    struct MethodsRecord {
        void (OldbAdapter::*read_metadata_method)(detail::ReadMetaDataRequest&);
        void (OldbAdapter::*write_metadata_method)(detail::WriteMetaDataRequest&);
        void (OldbAdapter::*delete_method)(const elt::mal::Uri&);
        void (OldbAdapter::*subscribe_method)(detail::ValueSubscribeRequest&);
    };
 
    using MethodLookupTable = std::unordered_map<std::type_index, MethodsRecord>;
    using MethodLookupTableEntry = typename MethodLookupTable::value_type;

    template <typename T>
    static MethodLookupTableEntry BindTypeHandlers();

    static const MethodsRecord& FindTypeHandlers(const std::type_info& type);

    static const MethodLookupTable S_TYPE_DISPATCH_TABLE;

    template <typename T>
    static RequestDispatcher<OldbAdapter>::TableEntries BindRequestHandlers();

    static const RequestDispatcher<OldbAdapter> S_REQUEST_DISPATCHER;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_OLDBADAPTER_HPP