repositoryIf.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_REPOSITORYIF_HPP
#define RTCTK_COMPONENTFRAMEWORK_REPOSITORYIF_HPP
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <future>
#include <vector>
 
#include <gsl/span>
 
#include <rtctk/componentFramework/dataPointPath.hpp>
#include <rtctk/componentFramework/matrixBuffer.hpp>
#include <rtctk/componentFramework/matrixSpan.hpp>
 
namespace rtctk::componentFramework {
 
class RepositoryIf {
public:
    using PathList = std::vector<DataPointPath>;
 
    class ReadRequest {
    public:
        class Parameters {
        public:
            Parameters() = default;
 
            explicit Parameters(const DataPointPath& path,
                                void* buffer,
                                const std::type_info& type,
                                const std::function<void()>& callback)
                : m_path(path), m_buffer(buffer), m_type(&type), m_callback(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()>& GetCallback() const {
                return m_callback;
            };
 
        private:
            DataPointPath m_path;
 
            void* m_buffer;
 
            const std::type_info* m_type;
 
            std::function<void()> m_callback;
        };
 
        template <typename T>
        void Add(const DataPointPath& path, T& buffer);
        template <typename T, typename F>
        void Add(const DataPointPath& path, T& buffer, F handler);
        inline const std::vector<Parameters>& GetParams() const {
            return m_params;
        };
        inline std::vector<Parameters>& GetParams() {
            return m_params;
        };
 
    private:
        std::vector<Parameters> m_params;
    };
 
    class WriteRequest {
    public:
        class Parameters {
        public:
            Parameters() = default;
 
            explicit Parameters(const DataPointPath& path,
                                const void* buffer,
                                const std::type_info& type,
                                const std::function<void()>& callback)
                : m_path(path), m_buffer(buffer), m_type(&type), m_callback(callback) {
            }
 
            inline const DataPointPath& GetPath() const {
                return m_path;
            };
            inline const void* GetBuffer() const {
                return m_buffer;
            };
            inline const std::type_info& GetType() const {
                return *m_type;
            };
            inline const std::function<void()>& GetCallback() const {
                return m_callback;
            };
 
        private:
            DataPointPath m_path;
 
            const void* m_buffer;
 
            const std::type_info* m_type;
 
            std::function<void()> m_callback;
        };
 
        template <typename T>
        void Add(const DataPointPath& path, const T& buffer);
        template <typename T, typename F>
        void Add(const DataPointPath& path, const T& buffer, F handler);
        inline const std::vector<Parameters>& GetParams() const {
            return m_params;
        };
        inline std::vector<Parameters>& GetParams() {
            return m_params;
        };
 
    private:
        std::vector<Parameters> m_params;
    };
 
    class Response {
    public:
        explicit Response(std::future<void>&& future) noexcept;
        Response(Response&& other) noexcept;
        Response& operator=(Response&& other) noexcept;
 
        void Wait();
 
        bool Wait(const std::chrono::microseconds& timeout);
 
    private:
        Response(const Response& other) = delete;
        Response& operator=(const Response& other) = delete;
 
        std::future<void> m_future;
    };
 
    virtual ~RepositoryIf();
 
    virtual void CreateDataPoint(const DataPointPath& path, const std::type_info& type) = 0;
 
    template <typename T>
    void CreateDataPoint(const DataPointPath& path);
    template <typename T>
    void CreateDataPoint(const DataPointPath& path, const T default_value);
 
    virtual void DeleteDataPoint(const DataPointPath& path) = 0;
 
    virtual const std::type_info& GetDataPointType(const DataPointPath& path) const = 0;
 
    virtual size_t GetDataPointSize(const DataPointPath& path) const = 0;
 
    virtual bool DataPointExists(const DataPointPath& path) const = 0;
 
    virtual std::pair<PathList, PathList> GetChildren(const DataPointPath& path) const = 0;
 
    template <typename T>
    T GetDataPoint(const DataPointPath& path) const;
    template <typename T>
    void SetDataPoint(const DataPointPath& path, const T value);
    template <typename T>
    void ReadDataPoint(const DataPointPath& path, T& buffer) const;
    template <typename T>
    void WriteDataPoint(const DataPointPath& path, const T& buffer);
    void WriteDataPoint(const DataPointPath& path, const char* buffer);
 
    virtual Response SendReadRequest(const ReadRequest& request) const = 0;
 
    virtual Response SendWriteRequest(const WriteRequest& request) = 0;
};
 
template <typename T>
void RepositoryIf::ReadRequest::Add(const DataPointPath& path, T& buffer) {
    m_params.push_back(Parameters(path, &buffer, typeid(buffer), nullptr));
}
 
template <typename T, typename F>
void RepositoryIf::ReadRequest::Add(const DataPointPath& path, T& buffer, F handler) {
    // Prepare a lambda with no arguments that also captures the buffer, i.e. it effectively
    // captures the type and allows us to store this in the m_callback member and invoke the
    // handler at a later time.
    auto callback = [handler, &buffer]() -> void { handler(buffer); };
    m_params.push_back(Parameters(path, &buffer, typeid(buffer), callback));
}
 
template <typename T>
void RepositoryIf::WriteRequest::Add(const DataPointPath& path, const T& buffer) {
    m_params.push_back(Parameters(path, &buffer, typeid(buffer), nullptr));
}
 
template <typename T, typename F>
void RepositoryIf::WriteRequest::Add(const DataPointPath& path, const T& buffer, F handler) {
    auto callback = [handler, &buffer]() -> void { handler(buffer); };
    m_params.push_back(Parameters(path, &buffer, typeid(buffer), callback));
}
 
template <typename T>
void RepositoryIf::CreateDataPoint(const DataPointPath& path) {
    CreateDataPoint(path, typeid(T));
}
 
template <typename T>
void RepositoryIf::CreateDataPoint(const DataPointPath& path, const T default_value) {
    CreateDataPoint<T>(path);
    SetDataPoint(path, default_value);
}
 
template <typename T>
T RepositoryIf::GetDataPoint(const DataPointPath& path) const {
    T data = T();
    ReadDataPoint(path, data);
    return data;
}
 
template <typename T>
void RepositoryIf::SetDataPoint(const DataPointPath& path, const T value) {
    WriteDataPoint(path, value);
}
 
template <typename T>
void RepositoryIf::ReadDataPoint(const DataPointPath& path, T& buffer) const {
    ReadRequest request;
    request.Add(path, buffer);
    SendReadRequest(request).Wait();
}
 
template <typename T>
void RepositoryIf::WriteDataPoint(const DataPointPath& path, const T& buffer) {
    WriteRequest request;
    request.Add(path, buffer);
    SendWriteRequest(request).Wait();
}
 
// The following specialisations are declared here so that they are used during compilation, but
// must actually be defined in the .cpp file to avoid linker failures.
template <>
void RepositoryIf::CreateDataPoint(const DataPointPath& path, const char* default_value);
 
template <>
void RepositoryIf::SetDataPoint(const DataPointPath& path, const char* value);
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_REPOSITORYIF_HPP