Class buffer

src/include/buffer.hpp:341–530

/// \note This class wraps a data type T over the underlying byte buffer.
template<typename T>
class buffer : public bytes {
public:
    /// \brief constructor
    buffer() : bytes() {}

    /// \brief constructor
    /// \param count the count
    buffer(size_t count) : bytes(count * sizeof(T)) {}

    /// \brief constructor
    /// \param data the data
    /// \param count the count
    buffer(T* data, size_t count)
        : bytes(reinterpret_cast<uint8_t*>(data), count * sizeof(T)) {}

    /// \brief shallow copy constructor
    /// \param other the other buffer
    buffer(const buffer& other) : bytes(other) {}

#ifdef __XRT__
    /// \brief constructor
    /// \param bo the bo
    buffer(xrt::bo& bo) : bytes(bo) {}

    /// \brief constructor
    /// \param count the count
    /// \param device the device
    /// \param kernel the kernel
    /// \param group_id the group id
    /// \param flags the flags
    buffer(xrt::device& device, size_t count)
        : bytes(device, count * sizeof(T)) {}
#endif

    /// \brief constructor
    /// \param vec the vector
    buffer(const std::vector<T>& vec)
        : bytes(reinterpret_cast<uint8_t*>(const_cast<T*>(vec.data())), vec.size() * sizeof(T))
    {
    }

    /// \brief constructor
    /// \param vec the vector
    /// \warning This also creates a shallow mapping.
    /// \warning The caller must ensure that the vector is not used (and remains valid)
    /// \warning after constructing this buffer.
    buffer(std::vector<T>&& vec)
        : bytes(reinterpret_cast<uint8_t*>(vec.data()), vec.size() * sizeof(T))
    {
    }

    /// \brief copy from
    /// \param vec the vector
    void copy_from(const std::vector<T>& vec) {
        if (vec.size() * sizeof(T) != this->size_) {
            throw std::runtime_error("Size mismatch in copy_from(vector)");
        }
        std::memcpy(data_, vec.data(), size_);