repositoryIf.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_REPOSITORYIF_HPP
#define RTCTK_COMPONENTFRAMEWORK_REPOSITORYIF_HPP
 
#include <cstdint>
#include <string>
#include <vector>
#include <future>
#include <map>
#include <typeindex>
#include <functional>
#include <chrono>
#include <rtctk/componentFramework/matrixBuffer.hpp>
#include <rtctk/componentFramework/dataPointPath.hpp>
 
namespace rtctk::componentFramework {
 
class RepositoryIf {
public:
    using StringList = std::vector<std::string>;
 
    class Request {
    public:
        struct Parameters
        {
            DataPointPath m_path;
 
            void* m_buffer;
 
            std::type_index m_type;
 
            std::function<void()> m_callback;
        };
 
        template <typename T> void Add(const DataPointPath& path, T& buffer);
        template <typename T> void Add(const DataPointPath& path, const T& buffer);
        template <typename T, typename F> void Add(const DataPointPath& path, T& buffer, F handler);
        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; };
 
    private:
        std::vector<Parameters> m_params;
    };
 
    class Response {
    public:
        Response(std::future<void>&& future) noexcept;
        Response(Response&& other) noexcept;
        Response& operator=(Response&& other) noexcept;
        void Wait();
        bool Wait(const std::chrono::seconds 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::string& type) = 0;
 
    template <typename T> void CreateDataPointV2(const DataPointPath& path);
    template <typename T> void CreateDataPointV2(const DataPointPath& path, const T default_value);
 
    virtual void DeleteDataPoint(const DataPointPath& path) = 0;
 
    virtual std::string 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<StringList, StringList> 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 Request& request) const = 0;
 
    virtual Response SendWriteRequest(const Request& request) = 0;
};
 
template <typename T>
void RepositoryIf::Request::Add(const DataPointPath& path, T& buffer) {
    m_params.push_back({path, &buffer, std::type_index(typeid(buffer))});
}
 
template <typename T>
void RepositoryIf::Request::Add(const DataPointPath& path, const T& buffer) {
    m_params.push_back({path, const_cast<T*>(&buffer), std::type_index(typeid(buffer))});
}
 
template <typename T, typename F>
void RepositoryIf::Request::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({path, &buffer, std::type_index(typeid(buffer)), callback});
}
 
template <typename T, typename F>
void RepositoryIf::Request::Add(const DataPointPath& path, const T& buffer, F handler) {
    auto callback = [handler, &buffer] () -> void { handler(buffer); };
    m_params.push_back({path, const_cast<T*>(&buffer), std::type_index(typeid(buffer)),
                        callback});
}
 
template <typename T>
void RepositoryIf::CreateDataPointV2(const DataPointPath& path) {
    static const std::map<std::type_index, std::string> type_map = {
        {std::type_index(typeid(bool)), "RtcBool"},
        {std::type_index(typeid(int32_t)), "RtcInt32"},
        {std::type_index(typeid(int64_t)), "RtcInt64"},
        {std::type_index(typeid(float)), "RtcFloat"},
        {std::type_index(typeid(double)), "RtcDouble"},
        {std::type_index(typeid(std::string)), "RtcString"},
        {std::type_index(typeid(std::vector<bool>)), "RtcVectorBool"},
        {std::type_index(typeid(std::vector<int32_t>)), "RtcVectorInt32"},
        {std::type_index(typeid(std::vector<int64_t>)), "RtcVectorInt64"},
        {std::type_index(typeid(std::vector<float>)), "RtcVectorFloat"},
        {std::type_index(typeid(std::vector<double>)), "RtcVectorDouble"},
        {std::type_index(typeid(std::vector<std::string>)), "RtcVectorString"},
        {std::type_index(typeid(MatrixBuffer<bool>)), "RtcMatrixBool"},
        {std::type_index(typeid(MatrixBuffer<int32_t>)), "RtcMatrixInt32"},
        {std::type_index(typeid(MatrixBuffer<int64_t>)), "RtcMatrixInt64"},
        {std::type_index(typeid(MatrixBuffer<float>)), "RtcMatrixFloat"},
        {std::type_index(typeid(MatrixBuffer<double>)), "RtcMatrixDouble"},
        {std::type_index(typeid(MatrixBuffer<std::string>)), "RtcMatrixString"}
    };
    std::string type = type_map.at(std::type_index(typeid(T)));
    CreateDataPoint(path, type);
}
 
template <typename T>
void RepositoryIf::CreateDataPointV2(const DataPointPath& path, const T default_value) {
    CreateDataPointV2<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 {
    Request request;
    request.Add(path, buffer);
    SendReadRequest(request).Wait();
}
 
template <typename T>
void RepositoryIf::WriteDataPoint(const DataPointPath& path, const T& buffer) {
    Request 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::CreateDataPointV2(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