binary_serialize.hpp

 
#ifndef BINARY_SERIALIZE_HPP_INCLUDED
#define BINARY_SERIALIZE_HPP_INCLUDED
 
#include "buffer/shared_buffer.hpp"
#include "serialize/extract_append.hpp"
 
#include <cstddef> // std::byte, std::size_t, std::nullptr_t
#include <cstdint> // std::uint32_t, etc
#include <optional>
#include <string>
#include <string_view>
#include <cstring> // std::memcpy
#include <type_traits>
#include <iterator> // value type of iterator
#include <array>
#include <cassert>
#include <concepts>
 
#include <iostream> // debugging
 
namespace chops {
 
template <typename Ctr>
concept supports_expandable_buffer = 
  std::same_as<Ctr::value_type, std::byte> &&
  requires (Ctr ctr) {
    { ctr.size() } -> std::integral;
    ctr.resize(std::size_t{});
    { ctr.data() } -> std::same_as<std::byte*>;
  }
 
template <typename Ctr>
concept supports_endian_expandable_buffer = 
  supports_expandable_buffer<Ctr> &&
  requires (Ctr ctr) { 
    typename Ctr::endian_type;
  }
 
template <supports_expandable_buffer Ctr = chops::mutable_shared_buffer,
         std::endian Endian = std::endian::little>
class expandable_buffer {
private:
  Ctr      m_ctr;
public:
  using endian_type = Endian;
  using value_type = std::byte;
  Ctr& get_buf() noexcept { return m_ctr; }
  std::size_t size() noexcept { return m_ctr.size(); }
  std::byte* data() noexcept { return m_ctr.data(); }
  void resize(std::size_t sz) noexcept m_ctr.resize(sz); }
};
 
/*
template <typename Cnt, typename Container>
Container extract_sequence(const std::byte* buf) noexcept(fill in) {
  Cnt c = extract_val<Cnt>(buf);
 
}
*/
 
 
/*
template <typename Cnt, typename Iter>
std::size_t append_sequence(std::byte* buf, Cnt cnt, Iter start, Iter end) noexcept {
  std::size_t num = 0;
  append_val(buf, cnt);
  num += cnt;
  while (start != end) {
    num += append_val(buf, *start);
    ++start;
  }
}
*/
 
template <std::size_t N>
class fixed_size_byte_array {
public:
  fixed_size_byte_array() noexcept : m_buf(), m_size(0u) { }
 
  std::size_t size() const noexcept {
    return m_size;
  }
  void resize(std::size_t sz) noexcept {
    assert(sz <= N);
    m_size = sz;
  }
  std::byte* data() noexcept {
    return m_buf.data();
  }
  void clear() noexcept {
    m_size = 0u;
  }
  
private:
  std::array<std::byte, N> m_buf;
  std::size_t              m_size;
};
 
 
// add a function parameter to the function overload set so that std::vector<std::byte> and 
// similar can be used for the Buf template parameter
struct adl_tag { };
 
 
namespace detail {
 
template <integral_or_byte CastTypeVal, integral_or_byte T, 
          supports_endian_expandable_buf Buf = expandable_buffer>
constexpr Buf& serialize_val(Buf& buf, const T& val) {
  auto old_sz = buf.size();
  buf.resize(old_sz + sizeof(CastTypeVal));
  append_val<Buf::endian_type>(buf.data()+old_sz, static_cast<CastTypeVal>(val));
  return buf;
}
 
template <integral_or_byte CastTypeVal, integral_or_byte T,
          supports_endian_expandable Buf = chops::mutable_shared_buffer>
constexpr Buf& serialize(Buf& buf, const T& val) {
  return serialize_val<CastTypeVal> (buf, val);
}
 
template <integral_or_byte CastTypeSz, integral_or_byte CastTypeVal,
          integral_or_byte T,
          supports_endian_expandable Buf = chops::mutable_shared_buffer>
constexpr Buf& serialize(Buf& buf, const T* seq, std::size_t sz) {
  serialize_val<CastTypeSz> (buf, sz);
  for (int i {0}; i < sz; ++i) {
    serialize_val<CastTypeVal>(buf, seq[i]);
  }
  return buf;
}
 
template <integral_or_byte CastTypeSz,
          supports_endian_expandable Buf = chops::mutable_shared_buffer>
constexpr Buf& serialize(Buf& buf, const std::string& str) {
  return serialize<CastTypeSz, std::byte> (buf, str.data(), std.size());
}
 
template <integral_or_byte CastTypeBool, integral_or_byte CastTypeVal,
          integral_or_byte T,
          supports_endian_expandable Buf = chops::mutable_shared_buffer>
constexpr Buf& serialize(Buf& buf, const std::optional<T>& val) {
  if (val) 
    serialize_val<CastTypeBool> (buf, 1);
    return serialize_val<CastTypeVal> (buf, *val);
  }
  serialize_val<CastTypeBool> (buf, 0);
}
 
}
 
 
template <typename CastValType, typename T, typename Buf = chops::mutable_shared_buffer,
          typename = std::enable_if_t<detail::is_arithmetic_or_byte<T>()> >
Buf& marshall(Buf& buf, const T& val) {
  return marshall<CastValType>(buf, val, adl_tag { });
}
 
// overloads for specific types
template <typename CastBoolType, typename Buf = chops::mutable_shared_buffer>
Buf& marshall(Buf& buf, bool b) {
  return marshall<CastBoolType>(buf, static_cast<CastBoolType>(b ? 1 : 0));
}
 
 
template <typename CastBoolType, typename CastValType, typename T, typename Buf = chops::mutable_shared_buffer>
Buf& marshall(Buf& buf, const std::optional<T>& val) {
  marshall<CastBoolType>(buf, val.has_value());
  if (val.has_value()) {
    if constexpr (detail::is_arithmetic_or_byte<T>()) {
      marshall<CastValType>(buf, *val);
    }
    else { // *val should be a UDT
      marshall(buf, *val);
    }
  }
  return buf;
}
 
// overload for sequences
template <typename CastCntType, typename CastValType, typename Iter, typename Buf = chops::mutable_shared_buffer,
          typename T = typename std::iterator_traits<Iter>::value_type>
Buf& marshall_seq(Buf& buf, std::size_t num_elems, Iter iter) {
  marshall<CastCntType>(buf, num_elems);
  for (std::size_t i = 0u; i < num_elems; ++i) {
    if constexpr (detail::is_arithmetic_or_byte<T>()) {
      marshall<CastValType>(buf, *iter);
    }
    else {
      marshall(buf, *iter);
    }
    ++iter;
  }
  return buf;
}
 
// efficiently append a buffer of bytes to the end of the existing buffer
template <typename Buf = chops::mutable_shared_buffer>
Buf& marshall_buf(Buf& buf, std::size_t num_bytes, const std::byte* append_buf) {
  auto old_sz = buf.size();
  buf.resize(old_sz + num_bytes);
  std::memcpy (buf.data()+old_sz, append_buf, num_bytes);
  return buf;
}
 
template <typename CastCntType, typename Buf = chops::mutable_shared_buffer>
Buf& marshall(Buf& buf, std::string_view str) {
  marshall<CastCntType>(buf, str.size());
  return marshall_buf(buf, str.size(), cast_ptr_to<std::byte>(str.data()));
}
 
template <typename CastCntType, typename Buf = chops::mutable_shared_buffer>
Buf& marshall(Buf& buf, const std::string& str) {
  return marshall<CastCntType>(buf, std::string_view(str));
}
 
template <typename CastCntType, typename Buf = chops::mutable_shared_buffer>
Buf& marshall(Buf& buf, const char* str) {
  return marshall<CastCntType>(buf, std::string_view(str));
}
 
} // end namespace
 
#endif