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:
            using CallbackType = std::function<void(const DataPointPath&)>;
 
            Parameters() = default;
 
            explicit Parameters(const DataPointPath& path,
                                bool value_requested,
                                void* buffer,
                                const std::type_info& type,
                                const CallbackType& removed_callback,
                                const CallbackType& newvalue_callback)
                : m_path(path)
                , m_value_requested(value_requested)
                , m_buffer(buffer)
                , m_type(&type)
                , m_removed_callback(removed_callback)
                , m_newvalue_callback(newvalue_callback) {
            }
 
            explicit Parameters(const DataPointPath& path,
                                void* buffer,
                                const std::type_info& type,
                                const CallbackType& removed_callback,
                                const CallbackType& newvalue_callback)
                : Parameters(path, true, buffer, type, removed_callback, newvalue_callback) {
            }
 
            inline const DataPointPath& GetPath() const {
                return m_path;
            };
            inline const bool GetValueRequested() const {
                return m_value_requested;
            }
            inline void* GetBuffer() const {
                return m_buffer;
            };
            inline const std::type_info& GetType() const {
                return *m_type;
            };
            inline const CallbackType& GetRemovedCallback() const {
                return m_removed_callback;
            };
            inline const CallbackType& GetNewValueCallback() const {
                return m_newvalue_callback;
            };
 
        private:
            DataPointPath m_path;
 
            bool m_value_requested;
 
            void* m_buffer;
 
            const std::type_info* m_type;
 
            CallbackType m_removed_callback;
            CallbackType 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);
 
        template <typename F>
        void AddValueChangedHandler(const DataPointPath& path, 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;
 
    using NotifyHandler = std::function<void(DataPointPath const& path)>;
 
    template <typename T>
    using ValueHandler = std::function<void(DataPointPath const& path, T& value)>;
 
    template <typename T, typename F>
    void Subscribe(const DataPointPath& path, T& buffer, F handler) const;
 
    template <typename F>
    void Subscribe(const DataPointPath& path, F handler) const {
        SubscribeRequest subscribe;
        if constexpr (std::is_convertible_v<F, NotifyHandler>) {
            subscribe.AddValueChangedHandler(path, handler);
        } else {
            // later we intend to support more callback types
            static_assert(std::is_convertible_v<F, NotifyHandler>, "Feature not supported");
        }
        SendSubscribeRequest(subscribe).Wait();
    }
 
    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) {
    static_assert(
        std::is_convertible_v<F, std::function<void(const DataPointPath&)>>,
        "The handler callback must have a signature compatible with void(const DataPointPath&).");
    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) {
    static_assert(std::is_convertible_v<F, ValueHandler<T>>,
                  "The handler callback must have a signature compatible with void(const"
                  " DataPointPath&, T&).");
    // 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, true, &buffer, typeid(buffer), nullptr, callback));
}
 
template <typename F>
void RepositorySubscriberIf::SubscribeRequest::AddValueChangedHandler(const DataPointPath& path,
                                                                      F handler) {
    static_assert(std::is_convertible_v<F, NotifyHandler>,
                  "The handler callback must have a signature compatible with void(const"
                  " DataPointPath&).");
    // We use a lambda here to have type erasure and allow storing callbacks for different types in
    // the m_newvalue_callback.
    auto callback = [handler](const DataPointPath& path) -> void { handler(path); };
    m_params.push_back(Parameters(path, false, nullptr, typeid(void), 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