repositorySubscriberIf.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_REPOSITORYSUBSCRIBERIF_HPP
#define RTCTK_COMPONENTFRAMEWORK_REPOSITORYSUBSCRIBERIF_HPP
 
#include <any>
 
#include <rtctk/componentFramework/repositoryIf.hpp>
 
namespace rtctk::componentFramework {
 
class RepositorySubscriberIf {
public:
    class SubscribeRequest {
    public:
        class Parameters {
        public:
            Parameters() = default;
 
            explicit Parameters(
                const DataPointPath& path,
                void* buffer,
                const std::type_info& type,
                const std::function<void(const DataPointPath&)>& removed_callback,
                const std::function<void(const DataPointPath&)>& newvalue_callback)
                : m_path(path)
                , m_buffer(buffer)
                , m_type(&type)
                , m_removed_callback(removed_callback)
                , m_newvalue_callback(newvalue_callback) {
            }
 
            inline const DataPointPath& GetPath() const {
                return m_path;
            };
            inline void* GetBuffer() const {
                return m_buffer;
            };
            inline const std::type_info& GetType() const {
                return *m_type;
            };
            inline const std::function<void(const DataPointPath&)>& GetRemovedCallback() const {
                return m_removed_callback;
            };
            inline const std::function<void(const DataPointPath&)>& GetNewValueCallback() const {
                return m_newvalue_callback;
            };
 
        private:
            DataPointPath m_path;
 
            void* m_buffer;
 
            const std::type_info* m_type;
 
            std::function<void(const DataPointPath&)> m_removed_callback;
            std::function<void(const DataPointPath&)> m_newvalue_callback;
        };
 
        template <typename F>
        void AddRemovedHandler(const DataPointPath& path, F handler);
 
        template <typename T, typename F>
        void AddNewValueHandler(const DataPointPath& path, T& buffer, F handler);
 
        inline const std::vector<Parameters>& GetParams() const {
            return m_params;
        };
 
    private:
        std::vector<Parameters> m_params;
    };
 
    class UnsubscribeRequest {
    public:
        class Parameters {
        public:
            Parameters() = default;
 
            explicit Parameters(const DataPointPath& path,
                                const bool unsubscribe_removed,
                                const bool unsubscribe_newvalue)
                : m_path(path)
                , m_unsubscribe_removed(unsubscribe_removed)
                , m_unsubscribe_newvalue(unsubscribe_newvalue) {
            }
 
            inline const DataPointPath& GetPath() const {
                return m_path;
            };
            inline bool GetUnsubscribeRemoved() const {
                return m_unsubscribe_removed;
            };
            inline bool GetUnsubscribeNewValue() const {
                return m_unsubscribe_newvalue;
            };
 
        private:
            DataPointPath m_path;
 
            bool m_unsubscribe_removed;
 
            bool m_unsubscribe_newvalue;
        };
 
        void AddRemovedHandler(const DataPointPath& path);
 
        void AddNewValueHandler(const DataPointPath& path);
 
        inline const std::vector<Parameters>& GetParams() const {
            return m_params;
        };
 
    private:
        std::vector<Parameters> m_params;
    };
 
    virtual ~RepositorySubscriberIf();
 
    virtual RepositoryIf::Response SendSubscribeRequest(const SubscribeRequest& request) const = 0;
 
    virtual RepositoryIf::Response
    SendUnsubscribeRequest(const UnsubscribeRequest& request) const = 0;
 
    template <typename T, typename F>
    void Subscribe(const DataPointPath& path, T& buffer, F handler) const;
 
    void Unsubscribe(const DataPointPath& path) const;
 
private:
    // This is a workaround to support Python bindings. We need to associate certain extra objects
    // and buffers under the hood that have to live as long as an instance of this class does.
    friend class PyRepositorySubscriberIf;
    std::any m_extra_objects;
};
 
template <typename F>
void RepositorySubscriberIf::SubscribeRequest::AddRemovedHandler(const DataPointPath& path,
                                                                 F handler) {
    m_params.push_back(Parameters(path, nullptr, typeid(void), handler, nullptr));
}
 
template <typename T, typename F>
void RepositorySubscriberIf::SubscribeRequest::AddNewValueHandler(const DataPointPath& path,
                                                                  T& buffer,
                                                                  F handler) {
    // We use a lambda here to have type erasure and allow storing callbacks for different types in
    // the m_newvalue_callback.
    auto callback = [handler, &buffer](const DataPointPath& path) -> void {
        handler(path, buffer);
    };
    m_params.push_back(Parameters(path, &buffer, typeid(buffer), nullptr, callback));
}
 
template <typename T, typename F>
void RepositorySubscriberIf::Subscribe(const DataPointPath& path, T& buffer, F handler) const {
    SubscribeRequest subscribe;
    subscribe.AddNewValueHandler(path, buffer, handler);
    SendSubscribeRequest(subscribe).Wait();
}
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_REPOSITORYSUBSCRIBERIF_HPP