repositoryIf.ipp

Go to the documentation of this file.

 
// Note this is a template implementation file and should not be included directly.
// The typical header protection macro is not added to avoid it showing up in Doxygen API
// documentation.
#pragma once
 
#include <rtctk/componentFramework/typeTraits.hpp>
 
#include <fmt/format.h>
 
#include <boost/container/vector.hpp>
#include <boost/core/demangle.hpp>
 
#include <cassert>
#include <exception>
#include <memory>
#include <unordered_set>
#include <utility>
 
namespace rtctk::componentFramework {
 
namespace detail {
 
template <typename T>
struct CreateRequest {
    using ElementType = T;
    DataPointPath path;
    gsl::span<const T> data;
    RepositoryIf::MetaData metadata;
    RepositoryIf::CallbackType callback;
};
 
struct DeleteRequest {
    DataPointPath path;
    RepositoryIf::CallbackType callback;
};
 
struct ExistsRequest {
    DataPointPath path;
    bool& result;
    RepositoryIf::CallbackType callback;
};
 
struct GetChildrenRequest {
    DataPointPath path;
    bool recurse;
    std::pair<RepositoryIf::PathList, RepositoryIf::PathList>& result;
    RepositoryIf::CallbackType callback;
};
 
template <typename T>
struct ReadRequest {
    using ElementType = T;
    using PrepareFunctionType = std::function<gsl::span<T>(const RepositoryIf::MetaData&)>;
    DataPointPath path;
    // The following function is given by the caller to prepare the buffer to be filled.
    // It can use the metadata available for the datapoint to resize the buffer object for
    // example. This is called by the adapter just before filling the returned span with
    // deserialised data.
    PrepareFunctionType prepare_buffer;
    std::optional<std::reference_wrapper<RepositoryIf::MetaData>> metadata;
    RepositoryIf::CallbackType callback;
};
 
template <typename T>
struct WriteRequest {
    using ElementType = T;
    DataPointPath path;
    gsl::span<const T> data;
    RepositoryIf::MetaData metadata;
    RepositoryIf::CallbackType callback;
};
 
template <typename T>
struct PartialReadRequest {
    using ElementType = T;
    DataPointPath path;
    gsl::span<T> data;
    RepositoryIf::MetaData input_metadata;
    std::optional<std::reference_wrapper<RepositoryIf::MetaData>> output_metadata;
    size_t offset;
    RepositoryIf::CallbackType callback;
};
 
template <typename T>
struct PartialWriteRequest {
    using ElementType = T;
    DataPointPath path;
    gsl::span<const T> data;
    RepositoryIf::MetaData metadata;
    size_t offset;
    RepositoryIf::CallbackType callback;
};
 
struct ReadMetaDataRequest {
    DataPointPath path;
    RepositoryIf::MetaData& metadata;
    RepositoryIf::CallbackType callback;
};
 
struct WriteMetaDataRequest {
    DataPointPath path;
    RepositoryIf::MetaData metadata;
    RepositoryIf::CallbackType callback;
};
 
struct CreateSymlinkRequest {
    DataPointPath path;
    DataPointPath link_path;
    RepositoryIf::CallbackType callback;
};
 
struct UpdateSymlinkRequest {
    DataPointPath path;
    DataPointPath link_path;
    RepositoryIf::CallbackType callback;
};
 
inline RtcUInt64 GetNumOfElements(const RtcVectorUInt64& shape) {
    RtcUInt64 nelements = 1;
    for (auto dimention : shape) {
        nelements *= dimention;
    }
    return nelements;
}
 
template <typename T>
struct UserTypeHandler {
    using BufferType = T;
 
    using ElementType = std::remove_cv_t<T>;
 
    using DataPointType = T;
 
    static const bool USES_TEMP_BUFFER = false;
 
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        static_assert(std::is_same_v<T, RtcBool> or std::is_same_v<T, RtcInt8> or
                          std::is_same_v<T, RtcInt16> or std::is_same_v<T, RtcInt32> or
                          std::is_same_v<T, RtcInt64> or std::is_same_v<T, RtcUInt8> or
                          std::is_same_v<T, RtcUInt16> or std::is_same_v<T, RtcUInt32> or
                          std::is_same_v<T, RtcUInt64> or std::is_same_v<T, RtcFloat> or
                          std::is_same_v<T, RtcDouble>,
                      "The scalar type is not supported.");
        return {};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return {&buffer, 1};
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return {&buffer, 1};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 0) {
            // The shape is for a scalar, so confirm the buffer size is correct.
            return true;
        } else {
            return false;
        }
    }
 
    static void CopyToTempBuffer(const BufferType& buffer,
                                 std::shared_ptr<TempBufferType>& temp_buffer,
                                 size_t offset,
                                 size_t count) = delete;
 
    static void CopyFromTempBuffer(BufferType& buffer,
                                   const std::shared_ptr<TempBufferType>& temp_buffer,
                                   size_t offset,
                                   size_t count) = delete;
};
 
template <>
struct UserTypeHandler<std::string> {
    using BufferType = std::string;
    using ElementType = std::remove_cv_t<typename BufferType::value_type>;
    using DataPointType = RtcString;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        return {buffer.size()};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return {buffer};
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return {buffer};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 1) {
            buffer.resize(shape[0]);
        } else {
            buffer.resize(GetNumOfElements(shape));
        }
        return true;
    }
};
 
template <>
struct UserTypeHandler<std::string_view> {
    using BufferType = std::string_view;
    using ElementType = std::remove_cv_t<typename BufferType::value_type>;
    using DataPointType = RtcString;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        return {buffer.size()};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) = delete;
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return {buffer.data(), buffer.size()};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 1 and shape[0] == buffer.size()) {
            // Cannot resize, but the shape and size is correct, so return true.
            return true;
        } else {
            return false;
        }
    }
};
 
template <typename T, typename A>
struct UserTypeHandler<std::vector<T, A>> {
    using BufferType = std::vector<T, A>;
    using ElementType = std::remove_cv_t<typename BufferType::value_type>;
    using DataPointType = RtcVector<ElementType>;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        static_assert(std::is_same_v<T, RtcBool> or std::is_same_v<T, RtcInt8> or
                          std::is_same_v<T, RtcInt16> or std::is_same_v<T, RtcInt32> or
                          std::is_same_v<T, RtcInt64> or std::is_same_v<T, RtcUInt8> or
                          std::is_same_v<T, RtcUInt16> or std::is_same_v<T, RtcUInt32> or
                          std::is_same_v<T, RtcUInt64> or std::is_same_v<T, RtcFloat> or
                          std::is_same_v<T, RtcDouble> or std::is_same_v<T, RtcString> or
                          std::is_same_v<T, std::byte>,
                      "The vector type is not supported.");
        return {buffer.size()};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return {buffer};
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return {buffer};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 1) {
            buffer.resize(shape[0]);
        } else {
            buffer.resize(GetNumOfElements(shape));
        }
        return true;
    }
};
 
template <typename A>
struct UserTypeHandler<std::vector<bool, A>> {
    using BufferType = std::vector<bool, A>;
    using ElementType = std::remove_cv_t<typename BufferType::value_type>;
    using DataPointType = RtcVectorBool;
    static const bool USES_TEMP_BUFFER = true;
    using TempBufferType = boost::container::vector<bool>;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        return {buffer.size()};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) = delete;
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) = delete;
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 1) {
            buffer.resize(shape[0]);
        } else {
            buffer.resize(GetNumOfElements(shape));
        }
        return true;
    }
 
    static void CopyToTempBuffer(const BufferType& buffer,
                                 std::shared_ptr<TempBufferType>& temp_buffer,
                                 size_t offset,
                                 size_t count) {
        assert((buffer.size() >= offset + count) && ("The input buffer is too small."));
        assert((temp_buffer->size() >= count) && ("The temporary buffer is too small."));
        std::copy(buffer.begin() + offset, buffer.begin() + offset + count, temp_buffer->begin());
    }
 
    static void CopyFromTempBuffer(BufferType& buffer,
                                   const std::shared_ptr<TempBufferType>& temp_buffer,
                                   size_t offset,
                                   size_t count) {
        assert((buffer.size() >= offset + count) && ("The output buffer is too small."));
        assert((temp_buffer->size() >= count) && ("The temporary buffer is too small."));
        std::copy(temp_buffer->begin(), temp_buffer->begin() + count, buffer.begin() + offset);
    }
};
 
template <typename T, typename A>
struct UserTypeHandler<boost::container::vector<T, A>> {
    using BufferType = boost::container::vector<T, A>;
    using ElementType = std::remove_cv_t<typename BufferType::value_type>;
    using DataPointType = RtcVector<ElementType>;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        static_assert(std::is_same_v<T, RtcBool> or std::is_same_v<T, RtcInt8> or
                          std::is_same_v<T, RtcInt16> or std::is_same_v<T, RtcInt32> or
                          std::is_same_v<T, RtcInt64> or std::is_same_v<T, RtcUInt8> or
                          std::is_same_v<T, RtcUInt16> or std::is_same_v<T, RtcUInt32> or
                          std::is_same_v<T, RtcUInt64> or std::is_same_v<T, RtcFloat> or
                          std::is_same_v<T, RtcDouble> or std::is_same_v<T, RtcString> or
                          std::is_same_v<T, std::byte>,
                      "The vector type is not supported.");
        return {buffer.size()};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return {buffer};
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return {buffer};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 1) {
            buffer.resize(shape[0]);
        } else {
            buffer.resize(GetNumOfElements(shape));
        }
        return true;
    }
};
 
template <typename T, decltype(gsl::dynamic_extent) N>
struct UserTypeHandler<gsl::span<T, N>> {
    using BufferType = gsl::span<T, N>;
    using ElementType = std::remove_cv_t<typename BufferType::value_type>;
    using DataPointType = RtcVector<ElementType>;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        static_assert(std::is_same_v<T, RtcBool> or std::is_same_v<T, RtcInt8> or
                          std::is_same_v<T, RtcInt16> or std::is_same_v<T, RtcInt32> or
                          std::is_same_v<T, RtcInt64> or std::is_same_v<T, RtcUInt8> or
                          std::is_same_v<T, RtcUInt16> or std::is_same_v<T, RtcUInt32> or
                          std::is_same_v<T, RtcUInt64> or std::is_same_v<T, RtcFloat> or
                          std::is_same_v<T, RtcDouble> or std::is_same_v<T, RtcString> or
                          std::is_same_v<T, std::byte>,
                      "The vector type is not supported.");
        return {buffer.size()};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return {buffer};
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return {buffer};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 1 and shape[0] == buffer.size()) {
            // Cannot resize, but the shape and size is correct, so return true.
            return true;
        } else {
            return false;
        }
    }
};
 
template <decltype(gsl::dynamic_extent) N>
struct UserTypeHandler<gsl::span<char, N>> {
    using BufferType = gsl::span<char, N>;
    using ElementType = std::remove_cv_t<typename BufferType::value_type>;
    using DataPointType = RtcString;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        return {buffer.size()};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return {buffer};
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return {buffer};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        return false;
    }
};
 
template <typename T, typename A>
struct UserTypeHandler<MatrixBuffer<T, A>> {
    using BufferType = MatrixBuffer<T, A>;
    using ElementType = std::remove_cv_t<typename BufferType::value_type>;
    using DataPointType = RtcMatrix<ElementType>;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        static_assert(std::is_same_v<T, RtcBool> or std::is_same_v<T, RtcInt8> or
                          std::is_same_v<T, RtcInt16> or std::is_same_v<T, RtcInt32> or
                          std::is_same_v<T, RtcInt64> or std::is_same_v<T, RtcUInt8> or
                          std::is_same_v<T, RtcUInt16> or std::is_same_v<T, RtcUInt32> or
                          std::is_same_v<T, RtcUInt64> or std::is_same_v<T, RtcFloat> or
                          std::is_same_v<T, RtcDouble> or std::is_same_v<T, RtcString>,
                      "The matrix type is not supported.");
        return {buffer.GetNrows(), buffer.GetNcols()};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return {buffer.data(), GetNumOfElements(GetShape(buffer))};
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return {buffer.data(), buffer.GetNrows() * buffer.GetNcols()};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 2) {
            buffer.resize(shape[0], shape[1]);
        } else {
            buffer.resize(1, GetNumOfElements(shape));
        }
        return true;
    }
};
 
template <typename A>
struct UserTypeHandler<MatrixBuffer<bool, A>> {
    using BufferType = MatrixBuffer<bool, A>;
    using ElementType = std::remove_cv_t<typename BufferType::value_type>;
    using DataPointType = RtcMatrixBool;
    static const bool USES_TEMP_BUFFER = true;
    using TempBufferType = boost::container::vector<bool>;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        return {buffer.GetNrows(), buffer.GetNcols()};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) = delete;
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) = delete;
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 2) {
            buffer.resize(shape[0], shape[1]);
        } else {
            buffer.resize(1, GetNumOfElements(shape));
        }
        return true;
    }
 
    static void CopyToTempBuffer(const BufferType& buffer,
                                 std::shared_ptr<TempBufferType>& temp_buffer,
                                 size_t offset,
                                 size_t count) {
        assert((buffer.size() >= offset + count) && ("The input buffer is too small."));
        assert((temp_buffer->size() >= count) && ("The temporary buffer is too small."));
        std::copy(buffer.begin() + offset, buffer.begin() + offset + count, temp_buffer->begin());
    }
 
    static void CopyFromTempBuffer(BufferType& buffer,
                                   const std::shared_ptr<TempBufferType>& temp_buffer,
                                   size_t offset,
                                   size_t count) {
        assert((buffer.size() >= offset + count) && ("The output buffer is too small."));
        assert((temp_buffer->size() >= count) && ("The temporary buffer is too small."));
        std::copy(temp_buffer->begin(), temp_buffer->begin() + count, buffer.begin() + offset);
    }
};
 
template <typename T>
struct UserTypeHandler<MatrixSpan<T>> {
    using BufferType = MatrixSpan<T>;
    using ElementType = std::remove_cv_t<typename BufferType::value_type>;
    using DataPointType = RtcMatrix<ElementType>;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        static_assert(std::is_same_v<T, RtcBool> or std::is_same_v<T, RtcInt8> or
                          std::is_same_v<T, RtcInt16> or std::is_same_v<T, RtcInt32> or
                          std::is_same_v<T, RtcInt64> or std::is_same_v<T, RtcUInt8> or
                          std::is_same_v<T, RtcUInt16> or std::is_same_v<T, RtcUInt32> or
                          std::is_same_v<T, RtcUInt64> or std::is_same_v<T, RtcFloat> or
                          std::is_same_v<T, RtcDouble> or std::is_same_v<T, RtcString>,
                      "The matrix type is not supported.");
        return {buffer.GetNrows(), buffer.GetNcols()};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return {buffer.data(), GetNumOfElements(GetShape(buffer))};
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return {buffer.data(), buffer.GetNrows() * buffer.GetNcols()};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 2 and shape[0] == buffer.GetNrows() and shape[1] == buffer.GetNcols()) {
            // Cannot resize, but the shape and size is correct, so return true.
            return true;
        } else {
            return false;
        }
    }
};
 
template <typename T, std::size_t N>
struct UserTypeHandler<std::array<T, N>> {
    using BufferType = std::array<T, N>;
    using ElementType = std::remove_cv_t<typename BufferType::value_type>;
    using DataPointType = RtcVector<ElementType>;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        static_assert(std::is_same_v<T, RtcBool> or std::is_same_v<T, RtcInt8> or
                          std::is_same_v<T, RtcInt16> or std::is_same_v<T, RtcInt32> or
                          std::is_same_v<T, RtcInt64> or std::is_same_v<T, RtcUInt8> or
                          std::is_same_v<T, RtcUInt16> or std::is_same_v<T, RtcUInt32> or
                          std::is_same_v<T, RtcUInt64> or std::is_same_v<T, RtcFloat> or
                          std::is_same_v<T, RtcDouble> or std::is_same_v<T, RtcString> or
                          std::is_same_v<T, std::byte>,
                      "The array type is not supported.");
        return {buffer.size()};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return {buffer};
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return {buffer};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 1 and shape[0] == buffer.size()) {
            // Cannot resize, but the shape and size is correct, so return true.
            return true;
        } else {
            return false;
        }
    }
};
 
template <std::size_t N>
struct UserTypeHandler<std::array<char, N>> {
    using BufferType = std::array<char, N>;
    using ElementType = std::remove_cv_t<typename BufferType::value_type>;
    using DataPointType = RtcString;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        return {buffer.size()};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return {buffer};
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return {buffer};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 1 and shape[0] == buffer.size()) {
            // Cannot resize, but the shape and size is correct, so return true.
            return true;
        } else {
            return false;
        }
    }
};
 
template <typename T, std::size_t N, std::size_t M>
struct UserTypeHandler<std::array<std::array<T, M>, N>> {
    using BufferType = std::array<std::array<T, M>, N>;
    using ElementType = std::remove_cv_t<T>;
    using DataPointType = RtcMatrix<ElementType>;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        static_assert(std::is_same_v<T, RtcBool> or std::is_same_v<T, RtcInt8> or
                          std::is_same_v<T, RtcInt16> or std::is_same_v<T, RtcInt32> or
                          std::is_same_v<T, RtcInt64> or std::is_same_v<T, RtcUInt8> or
                          std::is_same_v<T, RtcUInt16> or std::is_same_v<T, RtcUInt32> or
                          std::is_same_v<T, RtcUInt64> or std::is_same_v<T, RtcFloat> or
                          std::is_same_v<T, RtcDouble> or std::is_same_v<T, RtcString>,
                      "The array type is not supported.");
        return {N, M};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        static_assert(sizeof(BufferType) == sizeof(ElementType) * N * M);
        ElementType* begin = &buffer[0][0];
        return {begin, N * M};
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        static_assert(sizeof(BufferType) == sizeof(ElementType) * N * M);
        const ElementType* begin = &buffer[0][0];
        return {begin, N * M};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 2 and shape[0] == N and shape[1] == M) {
            // Cannot resize, but the shape and size is correct, so return true.
            return true;
        } else {
            return false;
        }
    }
};
 
template <typename T, std::size_t N>
struct UserTypeHandler<T[N]> {
    using BufferType = T[N];
    using ElementType = std::remove_cv_t<T>;
    using DataPointType = RtcVector<ElementType>;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        static_assert(std::is_same_v<T, RtcBool> or std::is_same_v<T, RtcInt8> or
                          std::is_same_v<T, RtcInt16> or std::is_same_v<T, RtcInt32> or
                          std::is_same_v<T, RtcInt64> or std::is_same_v<T, RtcUInt8> or
                          std::is_same_v<T, RtcUInt16> or std::is_same_v<T, RtcUInt32> or
                          std::is_same_v<T, RtcUInt64> or std::is_same_v<T, RtcFloat> or
                          std::is_same_v<T, RtcDouble> or std::is_same_v<T, RtcString> or
                          std::is_same_v<T, std::byte>,
                      "The array type is not supported.");
        return {N};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return {buffer};
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return {buffer};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 1 and shape[0] == N) {
            // Cannot resize, but the shape and size is correct, so return true.
            return true;
        } else {
            return false;
        }
    }
};
 
template <std::size_t N>
struct UserTypeHandler<char[N]> {
    using BufferType = char[N];
    using ElementType = char;
    using DataPointType = RtcString;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        return {N};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        return {buffer};
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        return {buffer};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 1 and shape[0] == N) {
            // Cannot resize, but the shape and size is correct, so return true.
            return true;
        } else {
            return false;
        }
    }
};
 
template <typename T, std::size_t N, std::size_t M>
struct UserTypeHandler<T[N][M]> {
    using BufferType = T[N][M];
    using ElementType = std::remove_cv_t<T>;
    using DataPointType = RtcMatrix<ElementType>;
    static const bool USES_TEMP_BUFFER = false;
    using TempBufferType = void;
 
    static RtcVectorUInt64 GetShape(const BufferType& buffer) {
        static_assert(std::is_same_v<T, RtcBool> or std::is_same_v<T, RtcInt8> or
                          std::is_same_v<T, RtcInt16> or std::is_same_v<T, RtcInt32> or
                          std::is_same_v<T, RtcInt64> or std::is_same_v<T, RtcUInt8> or
                          std::is_same_v<T, RtcUInt16> or std::is_same_v<T, RtcUInt32> or
                          std::is_same_v<T, RtcUInt64> or std::is_same_v<T, RtcFloat> or
                          std::is_same_v<T, RtcDouble> or std::is_same_v<T, RtcString>,
                      "The array type is not supported.");
        return {N, M};
    }
 
    static gsl::span<ElementType> MakeSpan(BufferType& buffer) {
        static_assert(sizeof(BufferType) == sizeof(ElementType) * N * M);
        return {&buffer[0][0], N * M};
    }
 
    static gsl::span<const ElementType> MakeSpan(const BufferType& buffer) {
        static_assert(sizeof(BufferType) == sizeof(ElementType) * N * M);
        return {&buffer[0][0], N * M};
    }
 
    static bool ResizeBuffer(BufferType& buffer, const RtcVectorUInt64& shape) {
        if (shape.size() == 2 and shape[0] == N and shape[1] == M) {
            // Cannot resize, but the shape and size is correct, so return true.
            return true;
        } else {
            return false;
        }
    }
};
 
}  // namespace detail
 
namespace {
 
inline bool TypeIsAllowedForValue(const std::type_info& type) {
    static const std::unordered_set<std::type_index> valid_types = {
        // Void values are acceptable and represent null values, e.g. equivalent to Python None.
        std::type_index(typeid(void)),
        std::type_index(typeid(RtcBool)),
        std::type_index(typeid(RtcInt8)),
        std::type_index(typeid(RtcInt16)),
        std::type_index(typeid(RtcInt32)),
        std::type_index(typeid(RtcInt64)),
        std::type_index(typeid(RtcUInt8)),
        std::type_index(typeid(RtcUInt16)),
        std::type_index(typeid(RtcUInt32)),
        std::type_index(typeid(RtcUInt64)),
        std::type_index(typeid(RtcFloat)),
        std::type_index(typeid(RtcDouble)),
        std::type_index(typeid(RtcString)),
        std::type_index(typeid(RtcBinary)),
        std::type_index(typeid(RtcVectorUInt64)),
        // The following is the type actually stored in the std::any object.
        std::type_index(typeid(std::reference_wrapper<const std::type_info>)),
        std::type_index(typeid(RepositoryIf::Timestamp)),
        std::type_index(typeid(DataPointPath)),
        std::type_index(typeid(std::set<DataPointPath>))};
 
#if __cplusplus >= 202002L
    return valid_types.contains(std::type_index(type));
#else
    return valid_types.find(std::type_index(type)) != valid_types.end();
#endif
}
 
inline const std::type_info& GetMetaDataReservedKeyType(const std::string& key) {
    static const std::map<std::string, const std::type_info&> reserved_key_types = {
        {"type", typeid(std::reference_wrapper<const std::type_info>)},
        {"shape", typeid(RtcVectorUInt64)},
        {"timestamp", typeid(RepositoryIf::Timestamp)},
        {"sequence_id", typeid(RtcUInt64)},
        {"symlink_target", typeid(DataPointPath)},
        {"symlinks", typeid(std::set<DataPointPath>)},
    };
    auto iter = reserved_key_types.find(key);
    if (iter != reserved_key_types.end()) {
        return iter->second;
    } else {
        return typeid(void);
    }
}
 
inline void CheckMetaDataTypeForReservedKeys(const std::string& key, const std::type_info& type) {
    const std::type_info& type_expected = GetMetaDataReservedKeyType(key);
    // Note that if "type" is void, i.e. a null value is being assigned, this is accepted as OK.
    if (type_expected != typeid(void) and type != typeid(void) and type_expected != type) {
        throw CII_MAKE_EXCEPTION(RepositoryIf::MetaData::TypeMismatch, key, type, type_expected);
    }
}
 
inline void CheckMetaDataValueType(const std::string& key, const std::type_info& type) {
    const std::type_info& type_expected = GetMetaDataReservedKeyType(key);
    if (type_expected != typeid(void)) {
        // Dealing with a reserved key. Therefore check that the type being assigned is the one that
        // is expected for such a key. Note that "type" being effectively a null value is OK.
        if (type != typeid(void) and type_expected != type) {
            throw CII_MAKE_EXCEPTION(
                RepositoryIf::MetaData::TypeMismatch, key, type, type_expected);
        }
    } else {
        // Dealing with a general unreserved user key. Therefore check that the type being assigned
        // is from the list of allowed types.
        if (not TypeIsAllowedForValue(type)) {
            throw CII_MAKE_EXCEPTION(RepositoryIf::MetaData::UnsupportedType, type);
        }
    }
}
 
template <typename T>
void CheckMetaDataValueType(const std::string& key) {
    static_assert(
        std::is_same_v<T, RtcBool> or std::is_same_v<T, RtcInt8> or std::is_same_v<T, RtcInt16> or
            std::is_same_v<T, RtcInt32> or std::is_same_v<T, RtcInt64> or
            std::is_same_v<T, RtcUInt8> or std::is_same_v<T, RtcUInt16> or
            std::is_same_v<T, RtcUInt32> or std::is_same_v<T, RtcUInt64> or
            std::is_same_v<T, RtcFloat> or std::is_same_v<T, RtcDouble> or
            std::is_same_v<T, RtcString> or std::is_same_v<T, RtcBinary> or
            std::is_same_v<T, RtcVectorUInt64> or std::is_same_v<T, const std::type_info&> or
            std::is_same_v<T, RepositoryIf::Timestamp> or std::is_same_v<T, DataPointPath> or
            std::is_same_v<T, std::set<DataPointPath>>,
        "The type is not supported for MetaData values.");
    if constexpr (std::is_same_v<T, const std::type_info&>) {
        CheckMetaDataTypeForReservedKeys(key, typeid(std::reference_wrapper<const std::type_info>));
    } else {
        CheckMetaDataTypeForReservedKeys(key, typeid(T));
    }
}
 
inline bool MetaDataKeyValueIsValid(const std::string& key, const std::any& value) {
    const std::type_info& type_expected = GetMetaDataReservedKeyType(key);
    if (type_expected != typeid(void)) {
        // Dealing with a reserved key. Therefore just check that the type of the value is the same
        // as the one expected.
        if (value.type() != typeid(void)) {
            return type_expected == value.type();
        } else {
            // If value has a void type, i.e. std::any is unassigned, this is a valid state.
            return true;
        }
    } else {
        // Dealing with a general unreserved user key. Therefore check that the value has a type
        // from the allowed list.
        return TypeIsAllowedForValue(value.type());
    }
}
 
template <typename T>
void CheckSpanSize(const T& span, const RepositoryIf::MetaData& metadata) {
    size_t expected_size = detail::GetNumOfElements(metadata["shape"].Cast<RtcVectorUInt64>());
    if (expected_size > span.size()) {
        throw CII_MAKE_EXCEPTION(RepositoryIf::BufferTooSmall, span.size(), expected_size);
    }
}
 
}  // namespace
 
inline bool RepositoryIf::MetaData::ConstValueProxy::HasValue() const noexcept {
    return m_value.has_value();
}
 
inline RepositoryIf::MetaData::ConstValueProxy::operator const std::any&() const {
    return m_value;
}
 
template <typename T>
const T& RepositoryIf::MetaData::ConstValueProxy::Cast() const {
    CheckMetaDataValueType<T>(m_key);
    if constexpr (std::is_same_v<T, const std::type_info&>) {
        return std::any_cast<std::reference_wrapper<const std::type_info>>(m_value).get();
    } else {
        return std::any_cast<const T&>(m_value);
    }
}
 
inline RepositoryIf::MetaData::ConstValueProxy::ConstValueProxy(const std::string& key,
                                                                const std::any& value)
    : m_key(key), m_value(value) {
}
 
inline bool RepositoryIf::MetaData::ValueProxy::HasValue() const noexcept {
    return m_value.has_value();
}
 
inline RepositoryIf::MetaData::ValueProxy::operator const std::any&() const {
    return m_value;
}
 
template <typename T>
T& RepositoryIf::MetaData::ValueProxy::Cast() {
    CheckMetaDataValueType<T>(m_key);
    if constexpr (std::is_same_v<T, const std::type_info&>) {
        return std::any_cast<std::reference_wrapper<const std::type_info>>(m_value).get();
    } else {
        return std::any_cast<T&>(m_value);
    }
}
 
template <typename T>
const T& RepositoryIf::MetaData::ValueProxy::Cast() const {
    CheckMetaDataValueType<T>(m_key);
    if constexpr (std::is_same_v<T, const std::type_info&>) {
        return std::any_cast<std::reference_wrapper<const std::type_info>>(m_value).get();
    } else {
        return std::any_cast<const T&>(m_value);
    }
}
 
template <typename T>
RepositoryIf::MetaData::ValueProxy& RepositoryIf::MetaData::ValueProxy::operator=(T&& rhs) {
    using U = std::remove_cv_t<std::remove_reference_t<T>>;
    if constexpr (std::is_same_v<U, ValueProxy> or std::is_same_v<U, ConstValueProxy>) {
        // If assigning from ValueProxy or ConstValueProxy then just copy the value.
        CheckMetaDataTypeForReservedKeys(m_key, rhs.m_value.type());
        m_value = rhs.m_value;
    } else if constexpr (std::is_rvalue_reference_v<decltype(rhs)>) {
        // Handle the case where we get an rvalue reference, i.e. dealing with a temp object.
        // Move/forward where possible to be more efficient.
        if constexpr (std::is_same_v<U, std::type_info>) {
            CheckMetaDataTypeForReservedKeys(m_key,
                                             typeid(std::reference_wrapper<const std::type_info>));
            m_value = std::make_any<std::reference_wrapper<const std::type_info>>(rhs);
        } else if constexpr (std::is_same_v<U, std::any>) {
            CheckMetaDataValueType(m_key, rhs.type());
            m_value = std::move(rhs);
        } else {
            CheckMetaDataValueType<U>(m_key);
            m_value = std::forward<T>(rhs);
        }
    } else {
        // Handle the case where we get an lvalue reference.
        if constexpr (std::is_same_v<U, std::type_info>) {
            CheckMetaDataTypeForReservedKeys(m_key,
                                             typeid(std::reference_wrapper<const std::type_info>));
            m_value = std::make_any<std::reference_wrapper<const std::type_info>>(rhs);
        } else if constexpr (std::is_same_v<U, std::any>) {
            CheckMetaDataValueType(m_key, rhs.type());
            m_value = rhs;
        } else {
            CheckMetaDataValueType<U>(m_key);
            m_value = rhs;
        }
    }
    assert(MetaDataKeyValueIsValid(m_key, m_value) &&
           ("Metadata was modified in an invalid manner."));
    return *this;
}
 
inline void RepositoryIf::MetaData::ValueProxy::Reset() noexcept {
    return m_value.reset();
}
 
inline RepositoryIf::MetaData::ValueProxy::ValueProxy(const std::string& key, std::any& value)
    : m_key(key), m_value(value) {
}
 
template <typename MapIterType, typename ProxyType>
typename RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::value_type&
RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::operator*() {
    m_pair.emplace(m_iterator->first, ProxyType(m_iterator->first, m_iterator->second));
    return m_pair.value();
}
 
template <typename MapIterType, typename ProxyType>
typename RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::value_type
RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::operator*() const {
    return value_type(m_iterator->first, ProxyType(m_iterator->first, m_iterator->second));
}
 
template <typename MapIterType, typename ProxyType>
typename RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::value_type*
RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::operator->() {
    m_pair.emplace(m_iterator->first, ProxyType(m_iterator->first, m_iterator->second));
    return &m_pair.value();
}
 
template <typename MapIterType, typename ProxyType>
const typename RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::value_type*
RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::operator->() const {
    m_pair.emplace(m_iterator->first, ProxyType(m_iterator->first, m_iterator->second));
    return &m_pair.value();
}
 
template <typename MapIterType, typename ProxyType>
RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>&
RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::operator++() {
    ++m_iterator;
    return *this;
}
 
template <typename MapIterType, typename ProxyType>
RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>
RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::operator++(int) {
    auto tmp = *this;
    ++m_iterator;
    return tmp;
}
 
template <typename MapIterType, typename ProxyType>
RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>&
RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::operator--() {
    --m_iterator;
    return *this;
}
 
template <typename MapIterType, typename ProxyType>
RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>
RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::operator--(int) {
    auto tmp = *this;
    --m_iterator;
    return tmp;
}
 
template <typename MapIterType, typename ProxyType>
bool RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::operator==(
    const RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>& rhs) const {
    return m_iterator == rhs.m_iterator;
}
 
template <typename MapIterType, typename ProxyType>
bool RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::operator!=(
    const RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>& rhs) const {
    return m_iterator != rhs.m_iterator;
}
 
template <typename MapIterType, typename ProxyType>
RepositoryIf::MetaData::IteratorImpl<MapIterType, ProxyType>::IteratorImpl(MapIterType&& iter)
    : m_iterator(std::forward<MapIterType>(iter)) {
}
 
inline RepositoryIf::MetaData::Iterator::Iterator(RepositoryIf::MetaData::MapType::iterator&& iter)
    : RepositoryIf::MetaData::IteratorImpl<RepositoryIf::MetaData::MapType::iterator,
                                           RepositoryIf::MetaData::ValueProxy>(
          std::forward<RepositoryIf::MetaData::MapType::iterator>(iter)) {
}
 
inline RepositoryIf::MetaData::ConstIterator::ConstIterator(
    RepositoryIf::MetaData::MapType::const_iterator&& iter)
    : RepositoryIf::MetaData::IteratorImpl<RepositoryIf::MetaData::MapType::const_iterator,
                                           RepositoryIf::MetaData::ConstValueProxy>(
          std::forward<RepositoryIf::MetaData::MapType::const_iterator>(iter)) {
}
 
inline RepositoryIf::MetaData::ReverseIterator::ReverseIterator(
    RepositoryIf::MetaData::MapType::reverse_iterator&& iter)
    : RepositoryIf::MetaData::IteratorImpl<RepositoryIf::MetaData::MapType::reverse_iterator,
                                           RepositoryIf::MetaData::ValueProxy>(
          std::forward<RepositoryIf::MetaData::MapType::reverse_iterator>(iter)) {
}
 
inline RepositoryIf::MetaData::ConstReverseIterator::ConstReverseIterator(
    MapType::const_reverse_iterator&& iter)
    : RepositoryIf::MetaData::IteratorImpl<RepositoryIf::MetaData::MapType::const_reverse_iterator,
                                           RepositoryIf::MetaData::ConstValueProxy>(
          std::forward<RepositoryIf::MetaData::MapType::const_reverse_iterator>(iter)) {
}
 
inline RepositoryIf::MetaData::TypeMismatch::Attributes::Attributes(
    const std::string& key, const std::type_info& type_used, const std::type_info& type_expected)
    : m_key(key), m_type_used(type_used), m_type_expected(type_expected) {
}
 
inline bool RepositoryIf::MetaData::Empty() const {
    return m_metadata.empty();
}
 
inline size_t RepositoryIf::MetaData::GetSize() const noexcept {
    return m_metadata.size();
}
 
inline bool RepositoryIf::MetaData::Contains(const std::string& key) const {
#if __cplusplus >= 202002L
    return m_metadata.contains(key);
#else
    return m_metadata.find(key) != m_metadata.end();
#endif
}
 
template <typename T>
auto& RepositoryIf::MetaData::Insert(const std::string& key, T&& value) {
    std::string key_copy = key;
    return Insert(std::move(key_copy), std::forward<T>(value));
}
 
template <typename T>
auto& RepositoryIf::MetaData::Insert(std::string&& key, T&& value) {
    using U = std::remove_cv_t<std::remove_reference_t<T>>;
    decltype(m_metadata)::iterator iter;
    bool inserted;
    if constexpr (std::is_same_v<U, std::type_info>) {
        // Handle the case where we are assigning a type_info as the value.
        CheckMetaDataTypeForReservedKeys(std::forward<std::string>(key),
                                         typeid(std::reference_wrapper<const std::type_info>));
        auto type = std::make_any<std::reference_wrapper<const std::type_info>>(value);
        std::tie(iter, inserted) = m_metadata.try_emplace(std::forward<std::string>(key), type);
    } else {
        CheckMetaDataValueType<U>(std::forward<std::string>(key));
        std::tie(iter, inserted) =
            m_metadata.try_emplace(std::forward<std::string>(key), std::forward<T>(value));
    }
    if (not inserted) {
        throw CII_MAKE_EXCEPTION(KeyAlreadyExists, std::forward<std::string>(key));
    }
    assert(MetaDataKeyValueIsValid(iter->first, iter->second) &&
           ("Metadata was modified in an invalid manner."));
    if constexpr (std::is_same_v<U, std::type_info>) {
        return std::any_cast<std::reference_wrapper<const std::type_info>>(iter->second).get();
    } else {
        return std::any_cast<U&>(iter->second);
    }
}
 
// The following methods are for STL compatibility and therefore must use lower case.
// NOLINTBEGIN(readability-identifier-naming)
inline RepositoryIf::MetaData::Iterator RepositoryIf::MetaData::begin() {
    return m_metadata.begin();
};
 
inline RepositoryIf::MetaData::ConstIterator RepositoryIf::MetaData::begin() const {
    return m_metadata.begin();
};
 
inline RepositoryIf::MetaData::ConstIterator RepositoryIf::MetaData::cbegin() const noexcept {
    return m_metadata.cbegin();
};
 
inline RepositoryIf::MetaData::Iterator RepositoryIf::MetaData::end() {
    return m_metadata.end();
};
 
inline RepositoryIf::MetaData::ConstIterator RepositoryIf::MetaData::end() const {
    return m_metadata.end();
};
 
inline RepositoryIf::MetaData::ConstIterator RepositoryIf::MetaData::cend() const noexcept {
    return m_metadata.cend();
};
 
inline RepositoryIf::MetaData::ReverseIterator RepositoryIf::MetaData::rbegin() {
    return m_metadata.rbegin();
};
 
inline RepositoryIf::MetaData::ConstReverseIterator RepositoryIf::MetaData::rbegin() const {
    return m_metadata.rbegin();
};
 
inline RepositoryIf::MetaData::ConstReverseIterator
RepositoryIf::MetaData::crbegin() const noexcept {
    return m_metadata.crbegin();
};
 
inline RepositoryIf::MetaData::ReverseIterator RepositoryIf::MetaData::rend() {
    return m_metadata.rend();
};
 
inline RepositoryIf::MetaData::ConstReverseIterator RepositoryIf::MetaData::rend() const {
    return m_metadata.rend();
};
 
inline RepositoryIf::MetaData::ConstReverseIterator RepositoryIf::MetaData::crend() const noexcept {
    return m_metadata.crend();
};
// NOLINTEND(readability-identifier-naming)
 
template <typename T>
void RepositoryIf::BatchRequest::CreateDataPoint(
    const DataPointPath& path,
    const T& initial_value,
    std::optional<std::reference_wrapper<const MetaData>> metadata,
    const CallbackType& callback) {
    using TypeHandler = detail::UserTypeHandler<T>;
 
    MetaData merged_metadata;
    if (metadata.has_value()) {
        merged_metadata = metadata.value();
    }
    auto shape = TypeHandler::GetShape(initial_value);
    merged_metadata["type"] = typeid(typename TypeHandler::DataPointType);
    merged_metadata["shape"] = shape;
 
    if constexpr (TypeHandler::USES_TEMP_BUFFER) {
        // If the type handler indicates it needs a temporary buffer, then we need to create it from
        // the initial_value buffer by resizing it appropriately and copying the data over.
        // Next, we create a span compatible with the new temporary buffer (not a span from the
        // original initial_value!), which is passed onto the actual request.
        using TempBufferType = typename TypeHandler::TempBufferType;
        using TempBufferHandler = detail::UserTypeHandler<TempBufferType>;
        auto temp_buffer = std::make_shared<TempBufferType>();
        bool buffer_resized = TempBufferHandler::ResizeBuffer(*temp_buffer, shape);
        if (not buffer_resized) {
            throw CII_MAKE_EXCEPTION(
                RepositoryIf::ServiceFailure,
                fmt::format("Resizing of a '{}' buffer should have succeeded.",
                            boost::core::demangle(typeid(TempBufferType).name())));
        }
        auto count = detail::GetNumOfElements(shape);
        TypeHandler::CopyToTempBuffer(initial_value, temp_buffer, 0, count);
        auto span = TempBufferHandler::MakeSpan(*temp_buffer);
 
        // A customised callback is also needed to cleanup the buffer once the request has
        // completed. Also need to remember to call the actual user callback if one was provided.
        auto cb = [temp_buffer, callback](const DataPointPath& path) mutable {
            temp_buffer.reset();
            if (callback) {
                callback(path);
            }
        };
 
        using ElementType = typename TempBufferHandler::ElementType;
        m_requests.push_back(detail::CreateRequest<ElementType>{
            path, std::move(span), std::move(merged_metadata), std::move(cb)});
    } else {
        // If a temporary buffer is not needed then just create the appropriate span directly from
        // the initial_value buffer and register the request.
        auto span = TypeHandler::MakeSpan(initial_value);
        using ElementType = typename TypeHandler::ElementType;
        m_requests.push_back(detail::CreateRequest<ElementType>{
            path, std::move(span), std::move(merged_metadata), callback});
    }
}
 
template <typename T>
void RepositoryIf::BatchRequest::ReadDataPoint(
    const DataPointPath& path,
    T& buffer,
    std::optional<std::reference_wrapper<MetaData>> metadata,
    const CallbackType& callback) const {
    static_assert(not std::is_same_v<T, std::string_view>,
                  "It is not possible to read data from a datapoint into a read-only string_view.");
 
    using TypeHandler = detail::UserTypeHandler<T>;
    using DataPointType = typename TypeHandler::DataPointType;  // Expected type of the data point.
 
    if constexpr (TypeHandler::USES_TEMP_BUFFER) {
        using TempBufferType = typename TypeHandler::TempBufferType;
        using TempBufferHandler = detail::UserTypeHandler<TempBufferType>;
        auto temp_buffer = std::make_shared<TempBufferType>();
 
        // If a temporary buffer is needed to handle the given data type T, we need to setup a
        // prepare_buffer callback that will allocate the temporary buffer and resize it to the
        // required size.
        // Note: "buffer" is maintained by the user, therefore its lifetime outlasts the request
        // and this callback invocation, therefore it can be captured by reference. The other
        // "temp_buffer" and user provided "callback" must be captured by value to have a copy that
        // will have a lifetime compatible with the invocation of the "prepare_buffer" and "cb"
        // functions.
        auto prepare_buffer = [&, temp_buffer](const MetaData& md) {
            assert((md.Contains("type")) && ("Adapter must provide the type in the metadata."));
            assert((md.Contains("shape")) && ("Adapter must provide the shape in the metadata."));
            if (md["type"].Cast<const std::type_info&>() != typeid(DataPointType)) {
                throw CII_MAKE_EXCEPTION(IncompatibleType, "Datapoint type mismatch.");
            }
            const auto& shape = md["shape"].Cast<RtcVectorUInt64>();
            TypeHandler::ResizeBuffer(buffer, shape);
            TempBufferHandler::ResizeBuffer(*temp_buffer, shape);
            // Note: no need to check if buffer was actually resized at this point.
            // This is effectively checked by the call to CheckSpanSize later.
            auto span = TempBufferHandler::MakeSpan(*temp_buffer);
            CheckSpanSize(span, md);
            return span;
        };
 
        // In the callback we copy the data from the temporary buffer into the original buffer.
        // Once the data is copied, cleanup the temporary buffer and remember to call the actual
        // user callback if one was provided.
        auto cb = [&, temp_buffer, callback](const DataPointPath& path) mutable {
            auto shape = TempBufferHandler::GetShape(*temp_buffer);
            auto count = detail::GetNumOfElements(shape);
            TypeHandler::CopyFromTempBuffer(buffer, temp_buffer, 0, count);
            temp_buffer.reset();
            if (callback) {
                callback(path);
            }
        };
 
        using ElementType = typename TempBufferHandler::ElementType;
        m_requests.push_back(detail::ReadRequest<ElementType>{
            path, std::move(prepare_buffer), metadata, std::move(cb)});
    } else {
        auto prepare_buffer = [&](const MetaData& md) {
            assert((md.Contains("type")) && ("Adapter must provide the type in the metadata."));
            assert((md.Contains("shape")) && ("Adapter must provide the shape in the metadata."));
            if (md["type"].Cast<const std::type_info&>() != typeid(DataPointType)) {
                throw CII_MAKE_EXCEPTION(IncompatibleType, "Datapoint type mismatch.");
            }
            TypeHandler::ResizeBuffer(buffer, md["shape"].Cast<RtcVectorUInt64>());
            auto span = TypeHandler::MakeSpan(buffer);
            CheckSpanSize(span, md);
            return span;
        };
 
        using ElementType = typename TypeHandler::ElementType;
        m_requests.push_back(
            detail::ReadRequest<ElementType>{path, std::move(prepare_buffer), metadata, callback});
    }
}
 
template <typename T>
void RepositoryIf::BatchRequest::WriteDataPoint(
    const DataPointPath& path,
    const T& buffer,
    std::optional<std::reference_wrapper<const MetaData>> metadata,
    const CallbackType& callback) {
    using TypeHandler = detail::UserTypeHandler<T>;
 
    MetaData merged_metadata;
    if (metadata.has_value()) {
        merged_metadata = metadata.value();
    }
    auto shape = TypeHandler::GetShape(buffer);
    merged_metadata["type"] = typeid(typename TypeHandler::DataPointType);
    merged_metadata["shape"] = shape;
 
    if constexpr (TypeHandler::USES_TEMP_BUFFER) {
        // If the type handler indicates it needs a temporary buffer, then create it, resize it to
        // the required size and copy the data from the input buffer into the temporary buffer.
        // Next, we create a span compatible with the new temporary buffer (not a span from the
        // original initial_value!), which is passed onto the actual request.
        using TempBufferType = typename TypeHandler::TempBufferType;
        using TempBufferHandler = detail::UserTypeHandler<TempBufferType>;
        auto temp_buffer = std::make_shared<TempBufferType>();
        bool buffer_resized = TempBufferHandler::ResizeBuffer(*temp_buffer, shape);
        if (not buffer_resized) {
            throw CII_MAKE_EXCEPTION(
                RepositoryIf::ServiceFailure,
                fmt::format("Resizing of a '{}' buffer should have succeeded.",
                            boost::core::demangle(typeid(TempBufferType).name())));
        }
        auto count = detail::GetNumOfElements(shape);
        TypeHandler::CopyToTempBuffer(buffer, temp_buffer, 0, count);
        auto span = TempBufferHandler::MakeSpan(*temp_buffer);
 
        // A customised callback is also needed to cleanup the buffer once the request has
        // completed. Remember to call the actual user callback if one was provided.
        auto cb = [temp_buffer, callback](const DataPointPath& path) mutable {
            temp_buffer.reset();
            if (callback) {
                callback(path);
            }
        };
 
        using ElementType = typename TempBufferHandler::ElementType;
        m_requests.push_back(detail::WriteRequest<ElementType>{
            path, std::move(span), std::move(merged_metadata), std::move(cb)});
    } else {
        auto span = TypeHandler::MakeSpan(buffer);
        using ElementType = typename TypeHandler::ElementType;
        m_requests.push_back(detail::WriteRequest<ElementType>{
            path, std::move(span), std::move(merged_metadata), callback});
    }
}
 
template <typename T>
void RepositoryIf::BatchRequest::PartialReadDataPoint(
    const DataPointPath& path,
    T& buffer,
    size_t first,
    size_t last,
    size_t d_first,
    std::optional<std::reference_wrapper<MetaData>> metadata,
    const CallbackType& callback) const {
    using TypeHandler = detail::UserTypeHandler<T>;
 
    auto shape = TypeHandler::GetShape(buffer);
    size_t buffer_size = detail::GetNumOfElements(shape);
    size_t expected_size = d_first + last - first;
    if (first > last or expected_size > buffer_size) {
        throw CII_MAKE_EXCEPTION(BufferTooSmall,
                                 buffer_size,
                                 expected_size,
                                 "Make sure first <= last and d_first + last - first <= number of "
                                 "elements in the output buffer.");
    }
    MetaData input_metadata;
    input_metadata["type"] = typeid(typename TypeHandler::DataPointType);
    input_metadata["shape"] = shape;
 
    if constexpr (TypeHandler::USES_TEMP_BUFFER) {
        // If a temporary buffer is needed to handle the given data type T, we create the temporary
        // buffer and resize it as a one dimensional array. It should hold just enough elements to
        // store the actual number that will be read from the datapoint.
        // Next, we create a span compatible with the new temporary buffer (not a span from the
        // original output buffer!), which is passed onto the actual request. Thus, the repository
        // adapter will actually write into the temporary buffer, from which we later copy back into
        // the original output buffer.
        using TempBufferType = typename TypeHandler::TempBufferType;
        using TempBufferHandler = detail::UserTypeHandler<TempBufferType>;
        auto temp_buffer = std::make_shared<TempBufferType>();
        bool buffer_resized = TempBufferHandler::ResizeBuffer(*temp_buffer, {last - first});
        if (not buffer_resized) {
            throw CII_MAKE_EXCEPTION(
                RepositoryIf::ServiceFailure,
                fmt::format("Resizing of a '{}' buffer should have succeeded.",
                            boost::core::demangle(typeid(TempBufferType).name())));
        }
        auto span = TempBufferHandler::MakeSpan(*temp_buffer);
        assert((span.size() >= last - first) &&
               ("The temporary buffer was not resized correctly."));
 
        // In the callback we copy the data from the temporary buffer into the original buffer.
        // Note: the temporary buffer is treated as a one dimensional array.
        // Once the data is copied, cleanup the temporary buffer and remember to call the actual
        // user callback if one was provided.
        auto cb =
            [&, temp_buffer, callback, first, last, d_first](const DataPointPath& path) mutable {
                TypeHandler::CopyFromTempBuffer(buffer, temp_buffer, d_first, last - first);
                temp_buffer.reset();
                if (callback) {
                    callback(path);
                }
            };
 
        using ElementType = typename TempBufferHandler::ElementType;
        m_requests.push_back(detail::PartialReadRequest<ElementType>{
            path, span, input_metadata, metadata, first, std::move(cb)});
    } else {
        auto span = TypeHandler::MakeSpan(buffer);
        using ElementType = typename TypeHandler::ElementType;
        m_requests.push_back(detail::PartialReadRequest<ElementType>{
            path, span.subspan(d_first, last - first), input_metadata, metadata, first, callback});
    }
}
 
template <typename T>
void RepositoryIf::BatchRequest::PartialWriteDataPoint(
    const DataPointPath& path,
    const T& buffer,
    size_t first,
    size_t last,
    size_t d_first,
    std::optional<std::reference_wrapper<const MetaData>> metadata,
    const CallbackType& callback) {
    using TypeHandler = detail::UserTypeHandler<T>;
 
    auto shape = TypeHandler::GetShape(buffer);
    size_t buffer_size = detail::GetNumOfElements(shape);
    if (first > last or last > buffer_size) {
        throw CII_MAKE_EXCEPTION(
            BufferTooSmall,
            buffer_size,
            last,
            "Make sure first <= last <= number of elements in the input buffer.");
    }
 
    MetaData merged_metadata;
    if (metadata.has_value()) {
        merged_metadata = metadata.value();
    }
    merged_metadata["type"] = typeid(typename TypeHandler::DataPointType);
    merged_metadata["shape"] = shape;
 
    if constexpr (TypeHandler::USES_TEMP_BUFFER) {
        // If a temporary buffer is needed to handle the given data type T, we create the temporary
        // buffer and resize it as a one dimensional array. It should hold just enough elements to
        // store the actual number that will be written to the datapoint.
        // The data from the original input buffer is then copied into the temporary buffer.
        // Next, we create a span compatible with the new temporary buffer (not a span from the
        // original input buffer!), which is passed onto the actual request.
        using TempBufferType = typename TypeHandler::TempBufferType;
        using TempBufferHandler = detail::UserTypeHandler<TempBufferType>;
        auto temp_buffer = std::make_shared<TempBufferType>();
        bool buffer_resized = TempBufferHandler::ResizeBuffer(*temp_buffer, {last - first});
        if (not buffer_resized) {
            throw CII_MAKE_EXCEPTION(
                RepositoryIf::ServiceFailure,
                fmt::format("Resizing of a '{}' buffer should have succeeded.",
                            boost::core::demangle(typeid(TempBufferType).name())));
        }
        TypeHandler::CopyToTempBuffer(buffer, temp_buffer, 0, last - first);
        auto span = TempBufferHandler::MakeSpan(*temp_buffer);
        assert((span.size() >= last - first) &&
               ("The temporary buffer was not resized correctly."));
 
        // A customised callback is also needed to cleanup the buffer once the request has
        // completed. Remember to call the actual user callback if one was provided.
        auto cb = [temp_buffer, callback](const DataPointPath& path) mutable {
            temp_buffer.reset();
            if (callback) {
                callback(path);
            }
        };
 
        using ElementType = typename TempBufferHandler::ElementType;
        m_requests.push_back(detail::PartialWriteRequest<ElementType>{
            path, span, std::move(merged_metadata), d_first, std::move(cb)});
    } else {
        auto span = TypeHandler::MakeSpan(buffer);
        using ElementType = typename TypeHandler::ElementType;
        m_requests.push_back(
            detail::PartialWriteRequest<ElementType>{path,
                                                     span.subspan(first, last - first),
                                                     std::move(merged_metadata),
                                                     d_first,
                                                     callback});
    }
}
 
template <typename Rep, typename Period>
bool RepositoryIf::BatchResponse::WaitFor(const std::chrono::duration<Rep, Period>& timeout) {
    // Calculate a timepoint in future that will correspond to the requested timeout period and then
    // invoke the WaitUntil implementation. We do it this way since we may have multiple futures to
    // check. Using WaitUntil will make sure the original timeout period is more closely adhered to
    // in such a case.
    auto maxtime = Clock::now();
    maxtime += std::chrono::duration_cast<Clock::duration>(timeout);
    return WaitUntil(maxtime);
}
 
template <typename Clk, typename Duration>
bool RepositoryIf::BatchResponse::WaitUntil(const std::chrono::time_point<Clk, Duration>& timeout) {
    // Check if every future in the responses list is ready.
    for (auto& response : m_responses) {
        if (response.wait_until(timeout) != std::future_status::ready) {
            return false;
        }
    }
    // If we got here then all futures are ready, therefore the call to Wait() should complete
    // without blocking.
    Wait();
    return true;
}
 
template <typename T>
void RepositoryIf::CreateDataPoint(const DataPointPath& path) {
    BatchRequest req;
    T value{};
    req.CreateDataPoint(path, value);
    SendRequest(req).Wait();
}
 
template <typename T>
void RepositoryIf::CreateDataPoint(const DataPointPath& path, const T& initial_value) {
    BatchRequest req;
    req.CreateDataPoint(path, initial_value);
    SendRequest(req).Wait();
}
 
template <typename T>
T RepositoryIf::GetDataPoint(const DataPointPath& path) const {
    BatchRequest req;
    T result;
    req.ReadDataPoint(path, result);
    SendRequest(req).Wait();
    return result;
}
 
template <typename T>
void RepositoryIf::SetDataPoint(const DataPointPath& path, const T& value) {
    BatchRequest req;
    req.WriteDataPoint(path, value);
    SendRequest(req).Wait();
}
 
template <typename T>
void RepositoryIf::ReadDataPoint(const DataPointPath& path, T& buffer) const {
    BatchRequest req;
    req.ReadDataPoint(path, buffer);
    SendRequest(req).Wait();
}
 
template <typename T>
void RepositoryIf::WriteDataPoint(const DataPointPath& path, const T& buffer) {
    BatchRequest req;
    req.WriteDataPoint(path, buffer);
    SendRequest(req).Wait();
}
 
template <typename... T>
void RepositoryIf::WriteDataPoints(const T&... args) {
    std::optional<std::reference_wrapper<const DataPointPath>> path_ref;
    BatchRequest req;
    (
        [&] {
            if constexpr (std::is_same_v<const DataPointPath&, decltype(args)>) {
                path_ref = args;
            } else {
                req.WriteDataPoint(path_ref.value().get(), args);
            }
        }(),
        ...);
    SendRequest(req).Wait();
}
 
template <typename... T>
void RepositoryIf::ReadDataPoints(T&... args) const {
    std::optional<std::reference_wrapper<const DataPointPath>> path_ref;
    BatchRequest req;
    (
        [&] {
            if constexpr (std::is_same_v<DataPointPath&, decltype(args)>) {
                path_ref = args;
            } else {
                req.ReadDataPoint(path_ref.value().get(), args);
            }
        }(),
        ...);
    SendRequest(req).Wait();
}
 
// The following are legacy methods:
 
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) {
    static_assert(std::is_convertible_v<F, std::function<void(T&)>>,
                  "The handler callback must have a signature compatible with void(T&).");
    // 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) {
    static_assert(std::is_convertible_v<F, std::function<void(const T&)>>,
                  "The handler callback must have a signature compatible with void(const T&).");
    auto callback = [handler, &buffer]() -> void { handler(buffer); };
    m_params.push_back(Parameters(path, &buffer, typeid(buffer), callback));
}
 
}  // namespace rtctk::componentFramework