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.

main
Zed A. Shaw 1 month ago
parent 713d400d17
commit bf57713416
  1. 41
      tests/config.cpp
  2. 266
      tser.hpp
  3. 11
      tser.wrap

@ -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);
}

@ -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; }

@ -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
Loading…
Cancel
Save