32#include <unordered_map>
33#include <unordered_set>
40template<
typename ...Ts>
44template<std::size_t Index,
typename,
typename ...Rest>
45static decltype(
auto) make_variant(std::size_t index)
48 return std::variant<Ts...>{std::in_place_index_t<Index>{}};
50 if constexpr(
sizeof...(Rest) != 0)
51 return make_variant<Index + 1, Rest...>(index);
53 throw std::runtime_error(
"Invalid variant index");
58template<
typename ...Ts>
59decltype(
auto) make_variant(std::size_t index)
65using remove_cvr_t = std::remove_cv_t<std::remove_reference_t<T>>;
104 const_cast<T&
>(data).serializeOp(*
this);
133 template<
class... Args>
138 variadic_call(data...);
142 variadic_call(data...);
159 template<
class... Args>
164 variadic_call(data...);
183 template <
typename T>
186 if constexpr (std::is_pod_v<T>) {
188 (*this)(data.size());
191 (*this)(data.size());
194 std::size_t size = 0;
196 auto& data_mut =
const_cast<std::vector<T>&
>(data);
197 data_mut.resize(size);
202 std::size_t size = 0;
204 auto& data_mut =
const_cast<std::vector<T>&
>(data);
205 data_mut.resize(size);
206 std::for_each(data_mut.begin(), data_mut.end(), std::ref(*
this));
208 (*this)(data.size());
209 std::for_each(data.begin(), data.end(), std::ref(*
this));
216 void vector(
const std::vector<bool>& data)
219 std::size_t size = 0;
221 auto& data_mut =
const_cast<std::vector<bool>&
>(data);
223 data_mut.reserve(size);
224 for (
size_t i = 0; i < size; ++i) {
227 data_mut.push_back(entry);
230 (*this)(data.size());
231 for (
const auto entry : data) {
240 template <
class Array>
243 using T =
typename Array::value_type;
245 if constexpr (std::is_pod_v<T>) {
251 auto& data_mut =
const_cast<Array&
>(data);
255 std::for_each(data.begin(), data.end(), std::ref(*
this));
261 template<
class... Args>
262 void variant(
const std::variant<Args...>& data)
265 std::size_t index = 0;
267 auto& data_mut =
const_cast<std::variant<Args...
>&>(data);
268 data_mut = detail::make_variant<Args...>(index);
269 std::visit(std::ref(*
this), data_mut);
271 (*this)(data.index());
272 std::visit(std::ref(*
this), data);
288 const_cast<std::optional<T>&
>(data) = res;
291 (*this)(data.has_value());
292 if (data.has_value()) {
300 template<
class Tuple>
313 std::size_t size = 0;
315 auto& data_mut =
const_cast<Map&
>(data);
316 for (
size_t i = 0; i < size; ++i) {
317 typename Map::value_type entry;
319 data_mut.insert(entry);
322 (*this)(data.size());
323 std::for_each(data.begin(), data.end(), std::ref(*
this));
334 std::size_t size = 0;
336 auto& data_mut =
const_cast<Set&
>(data);
337 for (
size_t i = 0; i < size; ++i) {
338 typename Set::value_type entry;
340 data_mut.insert(entry);
343 (*this)(data.size());
344 std::for_each(data.begin(), data.end(), std::ref(*
this));
348 template<
typename T,
typename... Args>
349 void variadic_call(T& first,
353 if constexpr (
sizeof...(args) > 0)
354 variadic_call(std::forward<Args>(args)...);
357 template<std::
size_t I = 0,
typename Tuple>
358 typename std::enable_if<I == std::tuple_size<Tuple>::value,
void>::type
359 tuple_call(
const Tuple&)
363 template<std::
size_t I = 0,
typename Tuple>
364 typename std::enable_if<I != std::tuple_size<Tuple>::value,
void>::type
365 tuple_call(
const Tuple&
tuple)
367 (*this)(std::get<I>(
tuple));
368 tuple_call<I+1>(
tuple);
381 constexpr static bool value =
false;
384 template<
class T1,
class Allocator>
386 constexpr static bool value =
true;
392 constexpr static bool value =
false;
395 template<
class... Ts>
397 constexpr static bool value =
true;
403 constexpr static bool value =
false;
406 template<
class... Ts>
408 constexpr static bool value =
true;
411 template<
class T1,
class T2>
413 constexpr static bool value =
true;
419 constexpr static bool value =
false;
424 constexpr static bool value =
true;
427 template<
class T1,
class Deleter>
428 struct is_ptr<std::unique_ptr<T1, Deleter>> {
429 constexpr static bool value =
true;
435 constexpr static bool value =
false;
440 constexpr static bool value =
true;
446 constexpr static bool value =
false;
449 template<
class Key,
class T,
class Compare,
class Allocator>
451 constexpr static bool value =
true;
454 template<
class Key,
class T,
class Hash,
class KeyEqual,
class Allocator>
455 struct is_map<std::unordered_map<Key,T,Hash,KeyEqual,Allocator>> {
456 constexpr static bool value =
true;
462 constexpr static bool value =
false;
465 template<
class Key,
class Compare,
class Allocator>
467 constexpr static bool value =
true;
470 template<
class Key,
class Hash,
class KeyEqual,
class Allocator>
471 struct is_set<std::unordered_set<Key,Hash,KeyEqual,Allocator>> {
472 constexpr static bool value =
true;
478 constexpr static bool value =
false;
481 template<
class T, std::
size_t N>
483 constexpr static bool value =
true;
489 template <
typename,
class =
void>
496 template <
typename T>
498 T, std::void_t<decltype(std::declval<T>().serializeOp(std::declval<Serializer<Packer>&>()))>
499 > :
public std::true_type {};
502 template<
class PtrType>
503 void ptr(
const PtrType& data)
505 using T1 =
typename PtrType::element_type;
506 bool value = data ? true :
false;
509 const_cast<PtrType&
>(data).reset(
new T1);
Class for (de-)serializing.
Definition: Serializer.hpp:75
void ptr(const PtrType &data)
Handler for smart pointers.
Definition: Serializer.hpp:503
void array(const Array &data)
Handler for arrays.
Definition: Serializer.hpp:241
void operator()(const T &data)
Applies current serialization op to the passed data.
Definition: Serializer.hpp:85
bool isSerializing() const
Returns true if we are currently doing a serialization operation.
Definition: Serializer.hpp:174
const Packer & m_packer
Packer to use.
Definition: Serializer.hpp:516
void tuple(const Tuple &data)
Handler for std::tuple.
Definition: Serializer.hpp:301
void set(const Set &data)
Handler for sets.
Definition: Serializer.hpp:331
Operation
Enumeration of operations.
Definition: Serializer.hpp:372
@ UNPACK
Performing de-serialization.
@ PACKSIZE
Calculating serialization buffer size.
@ PACK
Performing serialization.
void unpack(T &data)
Call this to de-serialize data.
Definition: Serializer.hpp:149
size_t position() const
Returns current position in buffer.
Definition: Serializer.hpp:168
void vector(const std::vector< T > &data)
Handler for vectors.
Definition: Serializer.hpp:184
size_t m_packSize
Required buffer size after PACKSIZE has been done.
Definition: Serializer.hpp:518
void pack(const Args &... data)
Call this to serialize data.
Definition: Serializer.hpp:134
void unpack(Args &... data)
Call this to de-serialize data.
Definition: Serializer.hpp:160
void vector(const std::vector< bool > &data)
Handler for bool vectors.
Definition: Serializer.hpp:216
Serializer(const Packer &packer)
Constructor.
Definition: Serializer.hpp:79
void variant(const std::variant< Args... > &data)
Handler for std::variant.
Definition: Serializer.hpp:262
void map(const Map &data)
Handler for maps.
Definition: Serializer.hpp:310
void pack(const T &data)
Call this to serialize data.
Definition: Serializer.hpp:119
Operation m_op
Current operation.
Definition: Serializer.hpp:517
void optional(const std::optional< T > &data)
Handler for std::optional.
Definition: Serializer.hpp:280
int m_position
Current position in buffer.
Definition: Serializer.hpp:519
std::vector< char > m_buffer
Buffer for serialized data.
Definition: Serializer.hpp:520
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition: Exceptions.hpp:29
Detect existence of serializeOp member function.
Definition: Serializer.hpp:490
Predicate for arrays.
Definition: Serializer.hpp:477
Predicate for maps.
Definition: Serializer.hpp:445
Predicate for std::optional.
Definition: Serializer.hpp:434
Predicate for detecting pairs and tuples.
Definition: Serializer.hpp:402
Predicate for smart pointers.
Definition: Serializer.hpp:418
Predicate for sets.
Definition: Serializer.hpp:461
Predicate for detecting variants.
Definition: Serializer.hpp:391
Predicate for detecting vectors.
Definition: Serializer.hpp:380
Definition: Serializer.hpp:42