fakeRepositoryIf.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_TEST_FAKEREPOSITORYIF_HPP
#define RTCTK_COMPONENTFRAMEWORK_TEST_FAKEREPOSITORYIF_HPP
 
#include <any>
#include <functional>
#include <map>
#include <typeinfo>
#include <unordered_map>
 
#include <rtctk/componentFramework/repositoryIf.hpp>
 
namespace rtctk::componentFramework::test {
 
class FakeRepositoryIf : virtual public RepositoryIf {
public:
    using RepositoryIf::CreateDataPoint;
    void CreateDataPoint(const DataPointPath&, const std::type_info&) override;
    void DeleteDataPoint(const DataPointPath&) override;
    const std::type_info& GetDataPointType(const DataPointPath&) const override;
    std::size_t GetDataPointSize(const DataPointPath&) const override;
    bool DataPointExists(const DataPointPath&) const override;
    std::pair<PathList, PathList> GetChildren(const DataPointPath&) const override;
    Response SendReadRequest(const ReadRequest&) const override;
    Response SendWriteRequest(const WriteRequest&) override;
 
protected:
    using DataPointMap = std::map<DataPointPath, std::any>;
 
    virtual void PreCreateDataPointHook(const DataPointPath&) const {};
    virtual void PostCreateDataPointHook(const DataPointPath&) const {};
 
    virtual void PreDeleteDataPointHook(const DataPointPath&) const {};
    virtual void PostDeleteDataPointHook(const DataPointPath&) const {};
 
    virtual void PreWriteDataPointHook(const DataPointPath&) const {};
    virtual void PostWriteDataPointHook(const DataPointPath&) const {};
 
    mutable DataPointMap m_datapoints;
 
    struct IoFunctionMapEntry {
        using CreateFunction = std::function<void(DataPointMap&, const DataPointPath&)>;
        using SizeFunction = std::function<std::size_t(const std::any&)>;
        using ReadFunction = std::function<void(const DataPointMap&, const DataPointPath&, void*)>;
        using WriteFunction = std::function<void(DataPointMap&, const DataPointPath&, const void*)>;
 
        CreateFunction m_create_function;
        SizeFunction m_size_function;
        ReadFunction m_read_function;
        WriteFunction m_write_function;
    };
 
    static const IoFunctionMapEntry& GetIoFunctions(const std::type_info& type);
 
    mutable std::mutex m_mutex;
 
private:
    template <typename R, typename F>
    Response ProcessRequest(const R& request, F selector) const;
 
    template <typename T>
    static void CreateDataPointImpl(DataPointMap& data, const DataPointPath& path);
 
    template <typename T>
    static std::size_t GetDataPointSizeImpl(const std::any& data);
 
    template <typename T>
    static void
    ReadDataPointImpl(const DataPointMap& data, const DataPointPath& path, void* buffer);
 
    template <typename T>
    static void
    WriteDataPointImpl(DataPointMap& data, const DataPointPath& path, const void* buffer);
 
    template <typename T>
    static auto MakeMapEntry();
 
    using IoFunctionMap = std::unordered_map<std::type_index, IoFunctionMapEntry>;
 
    static const IoFunctionMap S_IO_FUNCTIONS;
};
 
}  // namespace rtctk::componentFramework::test
 
#endif  // RTCTK_COMPONENTFRAMEWORK_TEST_FAKEREPOSITORYIF_HPP