fakeRepository.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_TEST_FAKEREPOSITORY_HPP
#define RTCTK_COMPONENTFRAMEWORK_TEST_FAKEREPOSITORY_HPP
 
#include <rtctk/componentFramework/dynamicThreadPool.hpp>
#include <rtctk/componentFramework/repositoryIf.hpp>
#include <rtctk/componentFramework/requestDispatcher.hpp>
 
namespace rtctk::componentFramework::test {

class FakeRepository : virtual public RepositoryIf {
public:
    FakeRepository();
    ~FakeRepository() override = default;
 
protected:
    struct Data {
        std::any value;
        MetaData metadata;
    };
 
    template <typename T>
    void CreateImpl(detail::CreateRequest<T>& req);
 
    template <typename T>
    void ReadImpl(detail::ReadRequest<T>& req);
 
    template <typename T>
    void WriteImpl(detail::WriteRequest<T>& req);
 
    template <typename T>
    void PartialReadImpl(detail::PartialReadRequest<T>& req);
 
    template <typename T>
    void PartialWriteImpl(detail::PartialWriteRequest<T>& req);
 
    void ReadMetaDataImpl(detail::ReadMetaDataRequest& req);
    void WriteMetaDataImpl(detail::WriteMetaDataRequest& req);
    void DeleteImpl(detail::DeleteRequest& req);
    void ExistsImpl(detail::ExistsRequest& req);
    std::pair<PathList, PathList> GetChildrenImpl(const DataPointPath& path);
    std::pair<PathList, PathList> GetChildrenRecursive(const DataPointPath& path);
    void GetChildrenImpl(detail::GetChildrenRequest& req);
    void CreateLinkImpl(detail::CreateSymlinkRequest& req);
    void UpdateLinkImpl(detail::UpdateSymlinkRequest& req);
 
    template <typename Request>
    void InvokeCallback(const Request& req) const;
 
    template <typename T>
    void ReadData(Data& data_node,
                  const DataPointPath& path,
                  gsl::span<T>& data,
                  std::optional<std::reference_wrapper<MetaData>>& metadata,
                  size_t offset);
 
    template <typename T>
    void WriteData(const DataPointPath& path,
                   const gsl::span<const T>& data,
                   const MetaData& metadata,
                   std::optional<std::reference_wrapper<MetaData>>,
                   size_t offset);
 
    void
    ReadMetaData(const DataPointPath& path, MetaData& metadata, bool check_sequence_id = false);
 
    void WriteMetaData(Data& data_node, const MetaData& metadata);
    DataPointPath ResolvePath(const DataPointPath& path);
    Data& CreateNewDataNode(const DataPointPath& path);
    virtual Data& GetDataNode(const DataPointPath& path);
    std::optional<std::reference_wrapper<FakeRepository::Data>>
    GetDataNodeNoThrow(const DataPointPath& path);
    void CheckDataNodeExists(const DataPointPath& path);
    virtual void InvokeRequestHandler(std::any& request);
    BatchResponse ProcessRequests(const RequestList& requests) override;
 
    bool RequestsToFailContains(size_t index) const;

    mutable std::mutex m_mutex;
 
    std::map<DataPointPath, Data> m_data;
 
    template <typename T>
    static RequestDispatcher<FakeRepository>::TableEntries BindTypeHandlers();
 
    static const RequestDispatcher<FakeRepository> S_REQUEST_DISPATCHER;
 
    DynamicThreadPool m_thread_pool{"repo_worker"};

    Data m_requests_to_fail;

    Data m_requests_to_skip;
};
 
}  // namespace rtctk::componentFramework::test
 
#endif  // RTCTK_COMPONENTFRAMEWORK_TEST_FAKEREPOSITORY_HPP