ser_buffer_binary.h

#pragma once
#include "gaia/config/config.h"
 
#include <type_traits>
 
#include "gaia/cnt/darray.h"
#include "gaia/cnt/darray_ext.h"
 
namespace gaia {
  namespace ser {
    enum class serialization_type_id : uint8_t;
 
    namespace detail {
      static constexpr uint32_t SerializationBufferCapacityIncreaseSize = 128U;
 
      template <typename DataContainer>
      class ser_buffer_binary_impl {
      protected:
        // Increase the capacity by multiples of CapacityIncreaseSize
        static constexpr uint32_t CapacityIncreaseSize = SerializationBufferCapacityIncreaseSize;
 
        DataContainer m_data;
        uint32_t m_dataPos = 0;
 
      public:
        void reset() {
          m_dataPos = 0;
          m_data.clear();
        }
 
        GAIA_NODISCARD uint32_t bytes() const {
          return (uint32_t)m_data.size();
        }
 
        GAIA_NODISCARD bool empty() const {
          return m_data.empty();
        }
 
        GAIA_NODISCARD const auto* data() const {
          return m_data.data();
        }
 
        void reserve(uint32_t size) {
          const auto nextSize = m_dataPos + size;
          if (nextSize <= bytes())
            return;
 
          // Make sure there is enough capacity to hold our data
          const auto newSize = bytes() + size;
          const auto newCapacity = ((newSize / CapacityIncreaseSize) * CapacityIncreaseSize) + CapacityIncreaseSize;
          m_data.reserve(newCapacity);
        }
 
        void resize(uint32_t size) {
          m_data.resize(size);
        }
 
        void seek(uint32_t pos) {
          m_dataPos = pos;
        }
 
        void skip(uint32_t size) {
          m_dataPos += size;
        }
 
        GAIA_NODISCARD uint32_t tell() const {
          return m_dataPos;
        }
 
        template <typename T>
        void save(T&& value) {
          reserve((uint32_t)sizeof(T));
 
          const auto cnt = m_dataPos + (uint32_t)sizeof(T);
          if (cnt > m_data.size())
            m_data.resize(cnt);
          mem::unaligned_ref<T> mem((void*)&m_data[m_dataPos]);
          mem = GAIA_FWD(value);
 
          m_dataPos += (uint32_t)sizeof(T);
        }
 
        void save_raw(const void* pSrc, uint32_t size, [[maybe_unused]] ser::serialization_type_id id) {
          if (size == 0)
            return;
 
          reserve(size);
 
          // Copy "size" bytes of raw data starting at pSrc
          const auto cnt = m_dataPos + size;
          if (cnt > m_data.size())
            m_data.resize(cnt);
          memcpy((void*)&m_data[m_dataPos], pSrc, size);
 
          m_dataPos += size;
        }
 
        template <typename T>
        void load(T& value) {
          GAIA_ASSERT(m_dataPos + (uint32_t)sizeof(T) <= bytes());
 
          const auto& cdata = std::as_const(m_data);
          value = mem::unaligned_ref<T>((void*)&cdata[m_dataPos]);
 
          m_dataPos += (uint32_t)sizeof(T);
        }
 
        void load_raw(void* pDst, uint32_t size, [[maybe_unused]] ser::serialization_type_id id) {
          if (size == 0)
            return;
 
          GAIA_ASSERT(m_dataPos + size <= bytes());
 
          const auto& cdata = std::as_const(m_data);
          memmove(pDst, (const void*)&cdata[m_dataPos], size);
 
          m_dataPos += size;
        }
      };
    } // namespace detail
 
    using ser_buffer_binary_storage = gaia::cnt::darray_ext<uint8_t, detail::SerializationBufferCapacityIncreaseSize>;
    using ser_buffer_binary_storage_dyn = gaia::cnt::darray<uint8_t>;
 
    class ser_buffer_binary: public detail::ser_buffer_binary_impl<ser_buffer_binary_storage> {};
    class ser_buffer_binary_dyn: public detail::ser_buffer_binary_impl<ser_buffer_binary_storage_dyn> {};
  } // namespace ser
} // namespace gaia