shared_buffer.hpp

 
#ifndef SHARED_BUFFER_HPP_INCLUDED
#define SHARED_BUFFER_HPP_INCLUDED
 
#include <cstddef> // std::byte
#include <vector>
#include <memory> // std::shared_ptr
#include <compare> // spaceship operator
#include <span>
#include <bit> // std::bit_cast
 
#include <utility> // std::move, std::swap
#include <algorithm> // std::copy
 
// TODO - add concepts and / or requires
//
// modify the templated constructor that takes a buffer of any valid 
// byte type, add constraints which makes the casting safer
 
namespace chops {
 
class const_shared_buffer;
 
class mutable_shared_buffer {
public:
  using byte_vec = std::vector<std::byte>;
  using size_type = typename byte_vec::size_type;
 
private:
  std::shared_ptr<byte_vec> m_data;
 
private:
 
  friend class const_shared_buffer;
 
  friend bool operator==(const mutable_shared_buffer&, const const_shared_buffer&) noexcept;
  friend bool operator==(const const_shared_buffer&, const mutable_shared_buffer&) noexcept;
 
public:
 
  // default copy and move construction, copy and move assignment
  mutable_shared_buffer(const mutable_shared_buffer&) = default;
  mutable_shared_buffer(mutable_shared_buffer&&) = default;
  mutable_shared_buffer& operator=(const mutable_shared_buffer&) = default;
  mutable_shared_buffer& operator=(mutable_shared_buffer&&) = default;
 
  mutable_shared_buffer() noexcept : 
      m_data{std::make_shared<byte_vec>(size_type(0))} { }
 
  template <std::size_t Ext>
  explicit mutable_shared_buffer(std::span<const std::byte, Ext> sp) : 
      m_data{std::make_shared<byte_vec>(sp.data(), sp.data()+sp.size())} { }
 
  mutable_shared_buffer(const std::byte* buf, std::size_t sz) : 
      mutable_shared_buffer(std::as_bytes(std::span<const std::byte>{buf, sz})) { }
 
  explicit mutable_shared_buffer(byte_vec&& bv) noexcept : 
      m_data{std::make_shared<byte_vec>(size_type(0))} {
    *m_data = std::move(bv);
  }
 
  explicit mutable_shared_buffer(size_type sz) : 
      m_data{std::make_shared<byte_vec>(sz)} { }
 
 
  template <typename T, std::size_t Ext>
  mutable_shared_buffer(std::span<const T, Ext> sp) : 
      mutable_shared_buffer(std::as_bytes(sp)) { }
 
  template <typename T>
  mutable_shared_buffer(const T* buf, size_type num) : 
      mutable_shared_buffer(std::as_bytes(std::span<const T>{buf, num})) { }
 
  mutable_shared_buffer(const void* buf, size_type sz) : 
      mutable_shared_buffer(std::as_bytes(
          std::span<const std::byte>{std::bit_cast<const std::byte*>(buf), sz})) { }
 
  template <typename InIt>
  mutable_shared_buffer(InIt beg, InIt end) : 
      m_data(std::make_shared<byte_vec>(beg, end)) { }
 
  std::byte* data() noexcept { return m_data->data(); }
 
  const std::byte* data() const noexcept { return m_data->data(); }
 
  size_type size() const noexcept { return m_data->size(); }
 
  byte_vec& get_byte_vec() noexcept { return *m_data; }
 
  bool empty() const noexcept { return m_data->empty(); }
 
  void clear() noexcept { m_data->clear(); }
 
  void resize(size_type sz) { m_data->resize(sz); }
 
  void swap(mutable_shared_buffer& rhs) noexcept {
    using std::swap; // swap idiom
    swap(m_data, rhs.m_data);
  }
 
  mutable_shared_buffer& append(const std::byte* buf, std::size_t sz) {
    size_type old_sz = size();
    resize(old_sz + sz); // set up buffer space
    std::copy(buf, buf+sz, data()+old_sz);
    return *this;
  }
 
  template <std::size_t Ext>
  mutable_shared_buffer& append(std::span<const std::byte, Ext> sp) {
    return append(sp.data(), sp.size());
  }
 
  template <typename T>
  mutable_shared_buffer& append(const T* buf, std::size_t num) {
    return append(std::as_bytes(std::span<const T>{buf, num}));
  }
 
  mutable_shared_buffer& append(const void* buf, size_type sz) {
    return append(std::as_bytes(
          std::span<const std::byte>{std::bit_cast<const std::byte*>(buf), sz}));
  }
 
  template <typename T, std::size_t Ext>
  mutable_shared_buffer& append(std::span<const T, Ext> sp) {
    return append(std::as_bytes(sp));
  }
 
  mutable_shared_buffer& append(const mutable_shared_buffer& rhs) {
    return append(rhs.data(), rhs.size());
  }
 
  mutable_shared_buffer& operator+=(const mutable_shared_buffer& rhs) {
    return append(rhs);
  }
 
  mutable_shared_buffer& append(std::byte b) {
    return append(&b, 1);
  }
 
  mutable_shared_buffer& operator+=(std::byte b) {
    return append(b);
  }
 
  bool operator== (const mutable_shared_buffer& rhs) const noexcept { 
    return *m_data == *rhs.m_data;
  }  
 
  auto operator<=>(const mutable_shared_buffer& rhs) const noexcept {
    return *m_data <=> *rhs.m_data;
  }
 
}; // end mutable_shared_buffer class
 
// non-member functions
inline void swap(mutable_shared_buffer& lhs, mutable_shared_buffer& rhs) noexcept {
  lhs.swap(rhs);
}
 
 
class const_shared_buffer {
public:
  using byte_vec = std::vector<std::byte>;
  using size_type = typename byte_vec::size_type;
 
private:
  std::shared_ptr<byte_vec> m_data;
 
private:
 
  friend bool operator==(const mutable_shared_buffer&, const const_shared_buffer&) noexcept;
  friend bool operator==(const const_shared_buffer&, const mutable_shared_buffer&) noexcept;
 
public:
 
  const_shared_buffer() = delete;
 
  // default copy and move construction, should do the right thing
  const_shared_buffer(const const_shared_buffer&) = default;
  const_shared_buffer(const_shared_buffer&&) = default;
  // copy and move assignment disabled
  const_shared_buffer& operator=(const const_shared_buffer&) = delete;
  const_shared_buffer& operator=(const_shared_buffer&&) = delete;
 
  template <std::size_t Ext>
  explicit const_shared_buffer(std::span<const std::byte, Ext> sp) : 
      m_data(std::make_shared<byte_vec>(sp.data(), sp.data()+sp.size())) { }
  const_shared_buffer(const std::byte* buf, std::size_t sz) : 
      const_shared_buffer(std::as_bytes(std::span<const std::byte>{buf, sz})) { }
 
  template <typename T, std::size_t Ext>
  const_shared_buffer(std::span<const T, Ext> sp) : 
      const_shared_buffer(std::as_bytes(sp)) { }
  template <typename T>
  const_shared_buffer(const T* buf, std::size_t num) : 
      const_shared_buffer(std::as_bytes(std::span<const T>{buf, num})) { }
 
  const_shared_buffer(const void* buf, size_type sz) : 
      const_shared_buffer(std::as_bytes(
          std::span<const std::byte>{std::bit_cast<const std::byte*>(buf), sz})) { }
 
  explicit const_shared_buffer(const mutable_shared_buffer& rhs) : 
      const_shared_buffer(rhs.data(), rhs.size()) { }
 
  explicit const_shared_buffer(mutable_shared_buffer&& rhs) noexcept : 
      m_data(std::move(rhs.m_data)) {
    rhs.m_data = std::make_shared<byte_vec>(0); // set rhs back to invariant
  }
 
  explicit const_shared_buffer(byte_vec&& bv) noexcept :
      m_data(std::make_shared<byte_vec>()) { 
    *m_data = std::move(bv);
  }
 
  template <typename InIt>
  const_shared_buffer(InIt beg, InIt end) : m_data(std::make_shared<byte_vec>(beg, end)) { }
 
  const std::byte* data() const noexcept { return m_data->data(); }
 
  size_type size() const noexcept { return m_data->size(); }
 
  bool empty() const noexcept { return (*m_data).empty(); }
 
  bool operator== (const const_shared_buffer& rhs) const noexcept { 
    return *m_data == *rhs.m_data;
  } 
  auto operator<=> (const const_shared_buffer& rhs) const noexcept {
    return *m_data <=> *rhs.m_data;
  }
 
}; // end const_shared_buffer class
 
// non-member functions
 
inline bool operator== (const const_shared_buffer& lhs, const mutable_shared_buffer& rhs) noexcept { 
  return *lhs.m_data == *rhs.m_data;
}  
 
inline bool operator== (const mutable_shared_buffer& lhs, const const_shared_buffer& rhs) noexcept { 
  return *lhs.m_data == *rhs.m_data;
}  
 
} // end namespace
 
#endif