Buffer.h

#pragma once
 
#include <xrpl/basics/Slice.h>
#include <xrpl/beast/utility/instrumentation.h>
 
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <memory>
#include <utility>
 
namespace xrpl {

class Buffer
{
private:
    std::unique_ptr<std::uint8_t[]> p_;
    std::size_t size_ = 0;
 
public:
    using const_iterator = std::uint8_t const*;
 
    Buffer() = default;

    explicit Buffer(std::size_t size)
        : p_((size != 0u) ? new std::uint8_t[size] : nullptr), size_(size)
    {
    }

    Buffer(void const* data, std::size_t size) : Buffer(size)
    {
        if (size != 0u)
            std::memcpy(p_.get(), data, size);
    }

    Buffer(Buffer const& other) : Buffer(other.p_.get(), other.size_)
    {
    }

    Buffer&
    operator=(Buffer const& other)
    {
        if (this != &other)
        {
            if (auto p = alloc(other.size_))
                std::memcpy(p, other.p_.get(), size_);
        }
        return *this;
    }

    Buffer(Buffer&& other) noexcept : p_(std::move(other.p_)), size_(other.size_)
    {
        other.size_ = 0;
    }

    Buffer&
    operator=(Buffer&& other) noexcept
    {
        if (this != &other)
        {
            p_ = std::move(other.p_);
            size_ = other.size_;
            other.size_ = 0;
        }
        return *this;
    }

    explicit Buffer(Slice s) : Buffer(s.data(), s.size())
    {
    }

    Buffer&
    operator=(Slice s)
    {
        // Ensure the slice isn't a subset of the buffer.
        XRPL_ASSERT(
            s.empty() || size_ == 0 || s.data() < p_.get() || s.data() >= p_.get() + size_,
            "xrpl::Buffer::operator=(Slice) : input not a subset");
 
        if (auto p = alloc(s.size()))
            std::memcpy(p, s.data(), s.size());
        return *this;
    }

    [[nodiscard]] std::size_t
    size() const noexcept
    {
        return size_;
    }
 
    [[nodiscard]] bool
    empty() const noexcept
    {
        return 0 == size_;
    }
 
    operator Slice() const noexcept
    {
        if (size_ == 0u)
            return Slice{};
        return Slice{p_.get(), size_};
    }

    [[nodiscard]] std::uint8_t const*
    data() const noexcept
    {
        return p_.get();
    }
 
    std::uint8_t*
    data() noexcept
    {
        return p_.get();
    }


    void
    fill(std::uint8_t value) noexcept
    {
        std::fill_n(p_.get(), size_, value);
    }

    void
    clear() noexcept
    {
        p_.reset();
        size_ = 0;
    }

    std::uint8_t*
    alloc(std::size_t n)
    {
        if (n != size_)
        {
            p_.reset((n != 0u) ? new std::uint8_t[n] : nullptr);
            size_ = n;
        }
        return p_.get();
    }
 
    // Meet the requirements of BufferFactory
    void*
    operator()(std::size_t n)
    {
        return alloc(n);
    }
 
    [[nodiscard]] const_iterator
    begin() const noexcept
    {
        return p_.get();
    }
 
    [[nodiscard]] const_iterator
    cbegin() const noexcept
    {
        return p_.get();
    }
 
    [[nodiscard]] const_iterator
    end() const noexcept
    {
        return p_.get() + size_;
    }
 
    [[nodiscard]] const_iterator
    cend() const noexcept
    {
        return p_.get() + size_;
    }
};
 
inline bool
operator==(Buffer const& lhs, Buffer const& rhs) noexcept
{
    if (lhs.size() != rhs.size())
        return false;
 
    if (lhs.empty())
        return true;
 
    return std::memcmp(lhs.data(), rhs.data(), lhs.size()) == 0;
}
 
}  // namespace xrpl