buffer.hpp

Go to the documentation of this file.

#ifndef KAGOME_COMMON_BUFFER
#define KAGOME_COMMON_BUFFER

#include <string_view>
#include <vector>

#include <fmt/format.h>
#include <boost/container_hash/hash.hpp>
#include <boost/operators.hpp>
#include <gsl/span>

#include "common/buffer_view.hpp"
#include "common/size_limited_containers.hpp"
#include "hexutil.hpp"
#include "macro/endianness_utils.hpp"
#include "outcome/outcome.hpp"

namespace kagome::common {

  template <size_t MaxSize>
  class SLBuffer : public SLVector<uint8_t, MaxSize> {
   public:
    using Base = SLVector<uint8_t, MaxSize>;

    template <size_t OtherMaxSize>
    using OtherSLBuffer = SLBuffer<OtherMaxSize>;

    SLBuffer() = default;

    explicit SLBuffer(const typename Base::Base &other) : Base(other) {}
    explicit SLBuffer(typename Base::Base &&other) : Base(std::move(other)) {}

    template <size_t OtherMaxSize>
    SLBuffer(const OtherSLBuffer<OtherMaxSize> &other) : Base(other) {}

    template <size_t OtherMaxSize>
    SLBuffer(OtherSLBuffer<OtherMaxSize> &&other) : Base(std::move(other)) {}

    SLBuffer(const BufferView &s) : Base(s.begin(), s.end()) {}

    template <size_t N>
    SLBuffer(const std::array<typename Base::value_type, N> &other)
        : Base(other.begin(), other.end()) {}

    SLBuffer(const uint8_t *begin, const uint8_t *end) : Base(begin, end){};

    using Base::Base;
    using Base::operator=;

    SLBuffer &reserve(size_t size) {
      Base::reserve(size);
      return *this;
    }

    SLBuffer &resize(size_t size) {
      Base::resize(size);
      return *this;
    }

    SLBuffer &operator+=(const BufferView &view) noexcept {
      return put(view);
    }

    SLBuffer &putUint8(uint8_t n) {
      SLBuffer::push_back(n);
      return *this;
    }

    SLBuffer &putUint32(uint32_t n) {
      n = htobe32(n);
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      const auto *begin = reinterpret_cast<uint8_t *>(&n);
      const auto *end = begin + sizeof(n) / sizeof(uint8_t);
      Base::insert(this->end(), begin, end);
      return *this;
    }

    SLBuffer &putUint64(uint64_t n) {
      n = htobe64(n);
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      const auto *begin = reinterpret_cast<uint8_t *>(&n);
      const auto *end = begin + sizeof(n) / sizeof(uint8_t);
      Base::insert(this->end(), begin, end);
      return *this;
    }

    SLBuffer &put(std::string_view view) {
      Base::insert(Base::end(), view.begin(), view.end());
      return *this;
    }

    SLBuffer &put(const BufferView &view) {
      Base::insert(Base::end(), view.begin(), view.end());
      return *this;
    }

    const std::vector<uint8_t> &asVector() const {
      return static_cast<const typename Base::Base &>(*this);
    }

    std::vector<uint8_t> &asVector() {
      return static_cast<typename Base::Base &>(*this);
    }

    std::vector<uint8_t> toVector() & {
      return static_cast<typename Base::Base &>(*this);
    }

    std::vector<uint8_t> toVector() && {
      return std::move(static_cast<typename Base::Base &>(*this));
    }

    SLBuffer subbuffer(size_t offset = 0, size_t length = -1) const {
      return SLBuffer(view(offset, length));
    }

    BufferView view(size_t offset = 0, size_t length = -1) const {
      return BufferView{gsl::make_span(*this).subspan(offset, length)};
    }

    std::string toHex() const {
      return hex_lower(*this);
    }

    static outcome::result<SLBuffer> fromHex(std::string_view hex) {
      OUTCOME_TRY(bytes, unhex(hex));
      return outcome::success(SLBuffer(std::move(bytes)));
    }

    std::string toString() const {
      return std::string{Base::cbegin(), Base::cend()};
    }

    std::string_view asString() const {
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      return std::string_view(reinterpret_cast<const char *>(Base::data()),
                              Base::size());
    }

    static SLBuffer fromString(const std::string_view &src) {
      return {src.begin(), src.end()};
    }

    using Base::operator==;

    bool operator==(const BufferView &other) const noexcept {
      return std::equal(
          Base::cbegin(), Base::cend(), other.cbegin(), other.cend());
    }

    template <size_t N>
    bool operator==(
        const std::array<typename Base::value_type, N> &other) const noexcept {
      return std::equal(
          Base::cbegin(), Base::cend(), other.cbegin(), other.cend());
    }

    using Base::operator<;

    bool operator<(const BufferView &other) const noexcept {
      return std::lexicographical_compare(
          Base::cbegin(), Base::cend(), other.cbegin(), other.cend());
    }

    template <size_t N>
    bool operator<(
        const std::array<typename Base::value_type, N> &other) const noexcept {
      return std::lexicographical_compare(
          Base::cbegin(), Base::cend(), other.cbegin(), other.cend());
    }
  };

  template <size_t MaxSize>
  inline std::ostream &operator<<(std::ostream &os,
                                  const SLBuffer<MaxSize> &buffer) {
    return os << BufferView(buffer);
  }

  typedef SLBuffer<std::numeric_limits<size_t>::max()> Buffer;

  static inline const Buffer kEmptyBuffer{};

  using BufferMutRef = std::reference_wrapper<Buffer>;
  using BufferConstRef = std::reference_wrapper<const Buffer>;

  namespace literals {
    inline Buffer operator""_buf(const char *c, size_t s) {
      std::vector<uint8_t> chars(c, c + s);
      return Buffer(std::move(chars));
    }

    // TODO(GaroRobe): After migrating to C++20 would be good to use
    //  literal operator template
    inline Buffer operator""_hex2buf(const char *c, size_t s) {
      return Buffer::fromHex({c, s}).value();
    }
  }  // namespace literals

}  // namespace kagome::common

template <size_t N>
struct std::hash<kagome::common::SLBuffer<N>> {
  size_t operator()(const kagome::common::SLBuffer<N> &x) const {
    return boost::hash_range(x.begin(), x.end());
  }
};

template <>
struct fmt::formatter<kagome::common::Buffer>
    : fmt::formatter<kagome::common::BufferView> {};

#endif  // KAGOME_COMMON_BUFFER