Stripped tser.hpp down to the essentials so I can study it. No base64 encoding, less than comparison (wtf is that for), and I may even remove the 'json' output.

tests/config.cpp

@@ -75,7 +75,9 @@ struct MyData
   std::string tiles;
 
   template<class Archive>
-    serialize(Archive &ar) { ar(x, y, z, tiles); }
+    void serialize(Archive &ar) {
+      ar(x, y, z, tiles);
+    }
 };
 
 
@@ -104,3 +106,40 @@ TEST_CASE("test using serialization", "[config]") {
     REQUIRE(m3.tiles == "\u2849█Ω♣");
   }
 }
+
+#include <optional>
+#include <iostream>
+#include "tser.hpp"
+
+enum class Item : char {
+  RADAR = 'R',
+  TRAP = 'T',
+  ORE = 'O'
+};
+
+struct Pixel {
+  int x = 0;
+  int y = 0;
+
+  DEFINE_SERIALIZABLE(Pixel, x, y);
+};
+
+struct Robot {
+  Pixel point;
+  std::optional<Item> item;
+
+  DEFINE_SERIALIZABLE(Robot, point, item);
+};
+
+TEST_CASE("test using tser for serialization", "[config]") {
+  auto robot = Robot{ Pixel{3,4}, Item::RADAR};
+  std::cout << robot << '\n';
+  std::cout << Robot() << '\n';
+
+  tser::BinaryArchive archive;
+  archive.save(robot);
+  std::string_view archive_view = archive.get_buffer();
+
+  auto loadedRobot = tser::load<Robot>(archive_view);
+  REQUIRE(loadedRobot == robot);
+}

tser.hpp

@@ -0,0 +1,266 @@
+// Licensed under the Boost License <https://opensource.org/licenses/BSL-1.0>.
+// SPDX-License-Identifier: BSL-1.0
+#pragma once
+#include <array>
+#include <ostream>
+#include <cstring>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <tuple>
+
+namespace tser{
+  //implementation details for C++20 is_detected
+  namespace detail {
+    struct ns {
+      ~ns() = delete;
+      ns(ns const&) = delete;
+    };
+
+    template <class Default, class AlwaysVoid, template<class...> class Op, class... Args>
+      struct detector {
+        using value_t = std::false_type;
+        using type = Default;
+      };
+
+    template <class Default, template<class...> class Op, class... Args>
+      struct detector<Default, std::void_t<Op<Args...>>, Op, Args...> {
+        using value_t = std::true_type;
+        using type = Op<Args...>;
+      };
+
+    template<class T>
+      struct is_array : std::is_array<T> {};
+
+    template<template<typename, size_t> class TArray, typename T, size_t N>
+      struct is_array<TArray<T, N>> : std::true_type {};
+
+    constexpr size_t n_args(char const* c, size_t nargs = 1) {
+      for (; *c; ++c) if (*c == ',') ++nargs;
+      return nargs;
+    }
+
+    constexpr size_t str_size(char const* c, size_t strSize = 1) {
+      for (; *c; ++c) ++strSize;
+      return strSize;
+    }
+  }
+
+  // we need a bunch of template metaprogramming for being able to differentiate between different types
+  template <template<class...> class Op, class... Args>
+    constexpr bool is_detected_v = detail::detector<detail::ns, void, Op, Args...>::value_t::value;
+
+  class BinaryArchive;
+  template<class T> using has_begin_t = decltype(*std::begin(std::declval<T>()));
+
+  template<class T> using has_members_t = decltype(std::declval<T>().members());
+
+  template<class T> using has_smaller_t = decltype(std::declval<T>() < std::declval<T>());
+
+  template<class T> using has_equal_t = decltype(std::declval<T>() == std::declval<T>());
+
+  template<class T> using has_nequal_t = decltype(std::declval<T>() != std::declval<T>());
+
+  template<class T> using has_outstream_op_t = decltype(std::declval<std::ostream>() << std::declval<T>());
+
+  template<class T> using has_tuple_t = std::tuple_element_t<0, T>;
+
+  template<class T> using has_optional_t = decltype(std::declval<T>().has_value());
+
+  template<class T> using has_element_t = typename T::element_type;
+
+  template<class T> using has_mapped_t = typename T::mapped_type;
+
+  template<class T> using has_custom_save_t = decltype(std::declval<T>().save(std::declval<BinaryArchive&>()));
+
+  template<class T> using has_free_save_t = decltype(std::declval<const T&>() << std::declval<BinaryArchive&>());
+
+  template<class T> constexpr bool is_container_v = is_detected_v<has_begin_t, T>;
+
+  template<class T> constexpr bool is_tuple_v = is_detected_v<has_tuple_t, T>;
+
+  template<class T> constexpr bool is_tser_t_v = is_detected_v<has_members_t, T>;
+
+  template<class T> constexpr bool is_pointer_like_v = std::is_pointer_v<T> || is_detected_v<has_element_t, T> || is_detected_v<has_optional_t, T>;
+
+  //implementation of the recursive json printing
+  template<typename T>
+    constexpr inline decltype(auto) print(std::ostream& os, T&& val) {
+      using V = std::decay_t<T>;
+      if constexpr (std::is_constructible_v<std::string, T> || std::is_same_v<V, char>) {
+        os << "\"" << val << "\"";
+      } else if constexpr (is_container_v<V>) {
+        size_t i = 0;
+        os << "\n[";
+
+        for (auto& elem : val) {
+          os << (i++ == 0 ? "" : ",") << tser::print(os, elem);
+        }
+
+        os << "]\n";
+      } else if constexpr (is_tser_t_v<V> && !is_detected_v<has_outstream_op_t, V>) {
+
+        auto pMem = [&](auto& ... memberVal) {
+          size_t i = 0;
+          (((os << (i != 0 ? ", " : "") << '\"'), os << V::_memberNames[i++] << "\" : " << tser::print(os, memberVal)), ...);
+        };
+
+        os << "{ \"" << V::_typeName << "\": {"; std::apply(pMem, val.members()); os << "}}\n";
+
+      } else if constexpr (std::is_enum_v<V> &&! is_detected_v<has_outstream_op_t, V>) {
+        os << tser::print(os, static_cast<std::underlying_type_t<V>>(val));
+      } else if constexpr (is_tuple_v<V> && !is_detected_v<has_outstream_op_t, V>) {
+        std::apply([&](auto& ... t) {
+            int i = 0;
+            os << "{";
+            (((i++ != 0 ? os << ", " : os),
+              tser::print(os, t)), ...); // WTF
+            os << "}";
+            }, val);
+      } else if constexpr (is_pointer_like_v<V>) {
+        os << (val ? (os << (tser::print(os, *val)), "") : "null");
+      } else {
+        os << val;
+      }
+
+      return "";
+    }
+
+  class BinaryArchive {
+    std::string m_bytes = std::string(1024, '\0');
+    size_t m_bufferSize = 0, m_readOffset = 0;
+
+    public:
+    explicit BinaryArchive(const size_t initialSize = 1024) : m_bytes(initialSize, '\0') {}
+
+    template<typename T>
+      explicit BinaryArchive(const T& t) { save(t); }
+
+    template<typename T>
+      void save(const T& t) {
+        if constexpr (is_detected_v<has_free_save_t, T>) {
+          operator<<(t,*this);
+        } else if constexpr (is_detected_v<has_custom_save_t, T>) {
+          t.save(*this);
+        } else if constexpr(is_tser_t_v<T>) {
+          std::apply([&](auto& ... mVal) { (save(mVal), ...); }, t.members());
+        } else if constexpr(is_tuple_v<T>) {
+          std::apply([&](auto& ... tVal) { (save(tVal), ...); }, t);
+        } else if constexpr (is_pointer_like_v<T>) {
+          save(static_cast<bool>(t));
+          if (t)
+            save(*t);
+        } else if constexpr (is_container_v<T>) {
+          if constexpr (!detail::is_array<T>::value) {
+            save(t.size());
+          }
+
+          for (auto& val : t) save(val);
+        } else {
+          if (m_bufferSize + sizeof(T) + sizeof(T) / 4 > m_bytes.size()) {
+            m_bytes.resize((m_bufferSize + sizeof(T)) * 2);
+          }
+
+          std::memcpy(m_bytes.data() + m_bufferSize, std::addressof(t), sizeof(T));
+          m_bufferSize += sizeof(T);
+        }
+      }
+
+    template<typename T>
+      void load(T& t) {
+        using V = std::decay_t<T>;
+        if constexpr (is_detected_v<has_free_save_t, V>) {
+          operator>>(t, *this);
+        } else if constexpr (is_detected_v<has_custom_save_t, T>) {
+          t.load(*this);
+        } else if constexpr (is_tser_t_v<T>) {
+          std::apply([&](auto& ... mVal) { (load(mVal), ...); }, t.members());
+        } else if constexpr (is_tuple_v<V>) {
+          std::apply([&](auto& ... tVal) { (load(tVal), ...); }, t);
+        } else if constexpr (is_pointer_like_v<T>) {
+          if constexpr (std::is_pointer_v<T>) {
+            t = load<bool>() ? (t = new std::remove_pointer_t<T>(), load(*t), t) : nullptr;
+          } else if constexpr (is_detected_v<has_optional_t, T>) {
+            t = load<bool>() ? T(load<typename V::value_type>()) : T();
+          } else { //smart pointer
+            t = T(load<has_element_t<V>*>());
+          }
+        } else if constexpr (is_container_v<T>) {
+          if constexpr (!detail::is_array<T>::value) {
+            const auto size = load<decltype(t.size())>();
+            using VT = typename V::value_type;
+            for (size_t i = 0; i < size; ++i) {
+              if constexpr (!is_detected_v<has_mapped_t, V>) {
+                t.insert(t.end(), load<VT>());
+              } else {
+                //we have to special case map, because of the const key
+                t.emplace(VT{ load<typename V::key_type>(), load<typename V::mapped_type>() });
+              }
+            }
+          } else {
+            for (auto& val : t) load(val);
+          }
+        } else {
+          std::memcpy(&t, m_bytes.data() + m_readOffset, sizeof(T));
+          m_readOffset += sizeof(T);
+        }
+      }
+
+    template<typename T>
+      T load() {
+        std::remove_const_t<T> t{}; load(t); return t;
+      }
+
+    template<typename T>
+      friend BinaryArchive& operator<<(BinaryArchive& ba, const T& t) {
+        ba.save(t); return ba;
+      }
+
+    template<typename T>
+      friend BinaryArchive& operator>>(BinaryArchive& ba, T& t) {
+        ba.load(t); return ba;
+      }
+
+    void reset() {
+      m_bufferSize = 0;
+      m_readOffset = 0;
+    }
+
+    void initialize(std::string_view str) {
+      m_bytes = str;
+      m_bufferSize = str.size();
+      m_readOffset = 0;
+    }
+
+    std::string_view get_buffer() const {
+      return std::string_view(m_bytes.data(), m_bufferSize);
+    }
+
+  };
+
+  template<class Base, typename Derived>
+    std::conditional_t<std::is_const_v<Derived>, const Base, Base>& base(Derived* thisPtr) { return *thisPtr; }
+
+  template<typename T>
+    auto load(std::string_view encoded) { BinaryArchive ba(encoded); return ba.load<T>(); }
+}
+
+//this macro defines printing, serialisation and comparision operators (==,!=,<) for custom types
+#define DEFINE_SERIALIZABLE(Type, ...) \
+inline decltype(auto) members() const { return std::tie(__VA_ARGS__); } \
+inline decltype(auto) members() { return std::tie(__VA_ARGS__); }  \
+static constexpr std::array<char, tser::detail::str_size(#__VA_ARGS__)> _memberNameData = [](){ \
+std::array<char, tser::detail::str_size(#__VA_ARGS__)> chars{'\0'}; size_t _idx = 0; constexpr auto* ini(#__VA_ARGS__);  \
+for (char const* _c = ini; *_c; ++_c, ++_idx) if(*_c != ',' && *_c != ' ') chars[_idx] = *_c;  return chars;}(); \
+static constexpr const char* _typeName = #Type; \
+static constexpr std::array<const char*, tser::detail::n_args(#__VA_ARGS__)> _memberNames = \
+[](){ std::array<const char*, tser::detail::n_args(#__VA_ARGS__)> out{ }; \
+for(size_t _i = 0, nArgs = 0; nArgs < tser::detail::n_args(#__VA_ARGS__) ; ++_i) { \
+while(Type::_memberNameData[_i] == '\0') _i++; out[nArgs++] = &Type::_memberNameData[_i]; \
+while(Type::_memberNameData[++_i] != '\0'); } return out;}();\
+template<typename OT, std::enable_if_t<std::is_same_v<OT,Type> && !tser::is_detected_v<tser::has_equal_t, OT>, int> = 0>\
+friend bool operator==(const Type& lhs, const OT& rhs) { return lhs.members() == rhs.members(); }\
+template<typename OT, std::enable_if_t<std::is_same_v<OT,Type> && !tser::is_detected_v<tser::has_nequal_t, OT>, int> = 0>\
+friend bool operator!=(const Type& lhs, const OT& rhs) { return !(lhs == rhs); }\
+template<typename OT, std::enable_if_t<std::is_same_v<OT,Type> && !tser::is_detected_v<tser::has_outstream_op_t, OT>, int> = 0>\
+friend std::ostream& operator<<(std::ostream& os, const OT& t) { tser::print(os, t); return os; }

tser.wrap

@@ -0,0 +1,11 @@
+[wrap-git]
+url = https://github.com/KonanM/tser.git
+depth = 1
+revision = HEAD
+method = cmake
+# patch_filename =
+# patch_hash =
+
+
+[provide]
+tser = tser_dep