ser_ct.h

#pragma once
#include "gaia/config/config.h"
 
#include <type_traits>
#include <utility>
 
#include "gaia/core/utility.h"
#include "gaia/ser/impl/ser_dispatch.h"
#include "gaia/ser/ser_common.h"
 
namespace gaia {
  namespace ser {
    namespace detail {
      template <typename Writer, typename T>
      void save_one(Writer& s, const T& arg) {
        auto saveTrivial = [](auto& writer, const auto& value) {
          writer.save(value);
        };
        save_dispatch(s, arg, saveTrivial);
      }
 
      template <typename Reader, typename T>
      void load_one(Reader& s, T& arg) {
        auto loadTrivial = [](auto& reader, auto& value) {
          reader.load(value);
        };
        load_dispatch(s, arg, loadTrivial);
      }
 
#if GAIA_ASSERT_ENABLED
      template <typename Writer, typename T>
      void check_one(Writer& s, const T& arg) {
        T tmp{};
 
        // Make sure that we write just as many bytes as we read.
        // If the positions are the same there is a good chance that save and load match.
        const auto pos0 = s.tell();
        save_one(s, arg);
        const auto pos1 = s.tell();
        s.seek(pos0);
        load_one(s, tmp);
        GAIA_ASSERT(s.tell() == pos1);
 
        // Return back to the original position in the buffer.
        s.seek(pos0);
      }
#endif
 
      class size_counter {
        uint32_t m_pos = 0;
 
      public:
        template <typename T>
        void save(const T&) {
          m_pos += (uint32_t)sizeof(T);
        }
 
        void save_raw(const void*, uint32_t size, [[maybe_unused]] ser::serialization_type_id id) {
          m_pos += size;
        }
 
        void seek(uint32_t pos) {
          m_pos = pos;
        }
 
        GAIA_NODISCARD uint32_t tell() const {
          return m_pos;
        }
      };
    } // namespace detail
 
    template <typename T>
    GAIA_NODISCARD uint32_t bytes(const T& data) {
      detail::size_counter counter;
      detail::save_one(counter, data);
      return counter.tell();
    }
 
    template <typename Writer, typename T>
    void save(Writer& writer, const T& data) {
      detail::save_one(writer, data);
    }
 
    template <typename Reader, typename T>
    void load(Reader& reader, T& data) {
      detail::load_one(reader, data);
    }
 
#if GAIA_ASSERT_ENABLED
    template <typename Writer, typename T>
    void check(Writer& writer, const T& data) {
      detail::check_one(writer, data);
    }
#endif
  } // namespace ser
} // namespace gaia