Slice.h

#pragma once
 
#include <xrpl/basics/contract.h>
#include <xrpl/basics/strHex.h>
#include <xrpl/beast/utility/instrumentation.h>
 
#include <algorithm>
#include <array>
#include <cstdint>
#include <cstring>
#include <limits>
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
namespace xrpl {

class Slice
{
private:
    std::uint8_t const* data_ = nullptr;
    std::size_t size_ = 0;
 
public:
    using value_type = std::uint8_t;
    using const_iterator = value_type const*;

    Slice() noexcept = default;
 
    Slice(Slice const&) noexcept = default;
    Slice&
    operator=(Slice const&) noexcept = default;

    Slice(void const* data, std::size_t size) noexcept
        : data_(reinterpret_cast<std::uint8_t const*>(data)), size_(size)
    {
    }

    [[nodiscard]] bool
    empty() const noexcept
    {
        return size_ == 0;
    }

    [[nodiscard]] std::size_t
    size() const noexcept
    {
        return size_;
    }
 
    [[nodiscard]] std::size_t
    length() const noexcept
    {
        return size_;
    }


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

    std::uint8_t
    operator[](std::size_t i) const noexcept
    {
        XRPL_ASSERT(i < size_, "xrpl::Slice::operator[](std::size_t) const : valid input");
        return data_[i];
    }

    Slice&
    operator+=(std::size_t n)
    {
        if (n > size_)
            Throw<std::domain_error>("too small");
        data_ += n;
        size_ -= n;
        return *this;
    }
 
    Slice
    operator+(std::size_t n) const
    {
        Slice temp = *this;
        return temp += n;
    }


    void
    removePrefix(std::size_t n)
    {
        data_ += n;
        size_ -= n;
    }

    void
    removeSuffix(std::size_t n)
    {
        size_ -= n;
    }
 
    [[nodiscard]] const_iterator
    begin() const noexcept
    {
        return data_;
    }
 
    [[nodiscard]] const_iterator
    cbegin() const noexcept
    {
        return data_;
    }
 
    [[nodiscard]] const_iterator
    end() const noexcept
    {
        return data_ + size_;
    }
 
    [[nodiscard]] const_iterator
    cend() const noexcept
    {
        return data_ + size_;
    }

    [[nodiscard]] Slice
    substr(std::size_t pos, std::size_t count = std::numeric_limits<std::size_t>::max()) const
    {
        if (pos > size())
            throw std::out_of_range("Requested sub-slice is out of bounds");
 
        return {data_ + pos, std::min(count, size() - pos)};
    }
};
 
//------------------------------------------------------------------------------
 
template <class Hasher>
inline void
hash_append(Hasher& h, Slice const& v)
{
    h(v.data(), v.size());
}
 
inline bool
operator==(Slice const& lhs, Slice 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;
}
 
inline bool
operator<(Slice const& lhs, Slice const& rhs) noexcept
{
    return std::lexicographical_compare(
        lhs.data(), lhs.data() + lhs.size(), rhs.data(), rhs.data() + rhs.size());
}
 
template <class Stream>
Stream&
operator<<(Stream& s, Slice const& v)
{
    s << strHex(v);
    return s;
}
 
template <class T, std::size_t N>
Slice
makeSlice(std::array<T, N> const& a)
    requires(std::is_same_v<T, char> || std::is_same_v<T, unsigned char>)
{
    return Slice(a.data(), a.size());
}
 
template <class T, class Alloc>
Slice
makeSlice(std::vector<T, Alloc> const& v)
    requires(std::is_same_v<T, char> || std::is_same_v<T, unsigned char>)
{
    return Slice(v.data(), v.size());
}
 
template <class Traits, class Alloc>
Slice
makeSlice(std::basic_string<char, Traits, Alloc> const& s)
{
    return Slice(s.data(), s.size());
}
 
template <class Traits>
Slice
makeSlice(std::basic_string_view<char, Traits> s)
{
    return Slice(s.data(), s.size());
}
 
}  // namespace xrpl