runtimeRepoAdapter.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_RUNTIMEREPOADAPTER_HPP
#define RTCTK_COMPONENTFRAMEWORK_RUNTIMEREPOADAPTER_HPP
 
#include <rtctk/componentFramework/dynamicThreadPool.hpp>
#include <rtctk/componentFramework/eventServiceIf.hpp>
#include <rtctk/componentFramework/malDdsEventService.hpp>
#include <rtctk/componentFramework/runtimeRepoIf.hpp>
 
namespace rtctk::componentFramework {
 
// forward declaration for internal usage
class RtrClient;

class RuntimeRepoAdapter : public RuntimeRepoIf {
public:
    inline static const std::string SUPPORTED_URI_SCHEME = "rtr";

    RuntimeRepoAdapter() = delete;

    RuntimeRepoAdapter(const RuntimeRepoAdapter&) = delete;

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

    RuntimeRepoAdapter(RuntimeRepoAdapter&&) = delete;
    RuntimeRepoAdapter& operator=(RuntimeRepoAdapter&&) = delete;

    explicit RuntimeRepoAdapter(const elt::mal::Uri& baseuri);
 
    ~RuntimeRepoAdapter() override = default;
 
    elt::mal::Uri GetUri() const override {
        return m_baseuri;
    }
 
protected:
    BatchResponse ProcessRequests(const RequestList& requests) override;
 
    template <typename T>
    void CreateImpl(detail::CreateRequest<T>&, RtrClient&);
 
    template <typename T>
    void WriteImpl(detail::WriteRequest<T>&, RtrClient&);
 
    template <typename T>
    void ReadImpl(detail::ReadRequest<T>&, RtrClient&);
 
    template <typename T>
    void PartialWriteImpl(detail::PartialWriteRequest<T>&, RtrClient&);
 
    template <typename T>
    void PartialReadImpl(detail::PartialReadRequest<T>&, RtrClient&);
 
    void WriteMetaDataImpl(detail::WriteMetaDataRequest&, RtrClient&);
    void ReadMetaDataImpl(detail::ReadMetaDataRequest&, RtrClient&);
 
    void DeleteImpl(detail::DeleteRequest&, RtrClient&);
    void ExistsImpl(detail::ExistsRequest&, RtrClient&);
    void GetChildrenImpl(detail::GetChildrenRequest&, RtrClient&);
    void CreateLinkImpl(detail::CreateSymlinkRequest&, RtrClient&);
    void UpdateLinkImpl(detail::UpdateSymlinkRequest&, RtrClient&);
 
    void SubscribeImpl(detail::ValueSubscribeRequest&, RtrClient&);
    void CreateDeleteSubscribeImpl(detail::CreateDeleteSubscribeRequest&, RtrClient&);
    void UnsubscribeImpl(detail::UnsubscribeRequest&, RtrClient&);
 
    virtual void InvokeRequestHandler(std::any&, RtrClient&);
    void SubscriptionCallbackHandler(const JsonPayload&);
 
    elt::mal::Uri m_baseuri;
    std::string m_ip;
    uint16_t m_port;
    std::string m_topic;

    DynamicThreadPool m_thread_pool{"rtr_worker"};

    DynamicThreadPool m_thread_pool_callback{"rtr_worker_c"};

    mutable std::mutex m_mutex;
 
    struct ValueSubscription {
        ValueSubscription(SubscriptionId,
                          const DataPointPath&,
                          NotifyCallbackType,
                          ErrorCallbackType);
        SubscriptionId id;
        DataPointPath path;
        NotifyCallbackType cb_value;
        ErrorCallbackType cb_error;
        std::atomic<size_t> cb_value_busy = 0;
        std::atomic<size_t> cb_error_busy = 0;
    };
 
    struct CreateDeleteSubscription {
        CreateDeleteSubscription(SubscriptionId, CallbackType, CallbackType, ErrorCallbackType);
        SubscriptionId id;
        CallbackType cb_created;
        CallbackType cb_deleted;
        ErrorCallbackType cb_error;
        std::atomic<size_t> cb_created_busy = 0;
        std::atomic<size_t> cb_deleted_busy = 0;
        std::atomic<size_t> cb_error_busy = 0;
    };
 
    std::list<ValueSubscription> m_value_subscriptions;
    std::list<CreateDeleteSubscription> m_create_delete_subscriptions;
 
    // TODO: ideally we would not instantiate a concrete EventService here,
    // but currently we cant get the abstract service interface from the service container,
    // so how to solve this?
    MalDdsEventService m_mal_event_service;
    EventServiceIf& m_event_service;
    std::unique_ptr<EventSubscriberIf> m_event_subscriber;
 
    using DispatchFunction = std::function<void(RuntimeRepoAdapter*, std::any&, RtrClient&)>;
    using LookupTable = std::unordered_map<std::type_index, DispatchFunction>;
    using TableEntry = typename LookupTable::value_type;
 
    template <typename T>
    static TableEntry Bind(void (RuntimeRepoAdapter::*method)(T&, RtrClient&));
 
    static const LookupTable S_REQUEST_DISPATCHER_TABLE;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_RUNTIMEREPOADAPTER_HPP