34#include <unordered_map>
35#include <unordered_set>
40namespace Dune {
template<
typename,
int>
class FieldVector; }
44namespace Dune {
template<
typename,
typename>
class BlockVector; }
50template<
typename ...Ts>
54template<std::size_t Index,
typename,
typename ...Rest>
55static decltype(
auto) make_variant(std::size_t index)
58 return std::variant<Ts...>{std::in_place_index_t<Index>{}};
60 if constexpr(
sizeof...(Rest) != 0)
61 return make_variant<Index + 1, Rest...>(index);
63 throw std::runtime_error(
"Invalid variant index");
68template<
typename ...Ts>
69decltype(
auto) make_variant(std::size_t index)
75using remove_cvr_t = std::remove_cv_t<std::remove_reference_t<T>>;
124 const_cast<T&
>(data).serializeOp(*
this);
156 template<
class...
Args>
162 variadic_call(data...);
167 variadic_call(data...);
187 template<
class...
Args>
193 variadic_call(data...);
213 template <
typename Vector>
216 if constexpr (std::is_pod_v<typename Vector::value_type>) {
218 (*this)(data.size());
219 if (data.size() > 0) {
223 (*this)(data.size());
224 if (data.size() > 0) {
228 std::size_t size = 0;
230 auto&
data_mut =
const_cast<Vector&
>(data);
238 std::size_t size = 0;
240 auto&
data_mut =
const_cast<Vector&
>(data);
244 (*this)(data.size());
245 std::for_each(data.begin(), data.end(), std::ref(*
this));
252 void vector(
const std::vector<bool>& data)
255 std::size_t size = 0;
257 auto&
data_mut =
const_cast<std::vector<bool>&
>(data);
260 for (
size_t i = 0; i < size; ++i) {
266 (*this)(data.size());
267 for (
const auto entry : data) {
276 template <
class Array>
279 using T =
typename Array::value_type;
281 if constexpr (std::is_pod_v<T>) {
287 auto&
data_mut =
const_cast<Array&
>(data);
291 std::for_each(data.begin(), data.end(), std::ref(*
this));
297 template<
class...
Args>
298 void variant(
const std::variant<Args...>& data)
301 std::size_t index = 0;
303 auto&
data_mut =
const_cast<std::variant<
Args...
>&>(data);
305 std::visit(std::ref(*
this),
data_mut);
307 (*this)(data.index());
308 std::visit(std::ref(*
this), data);
324 const_cast<std::optional<T>&
>(data) = res;
326 const_cast<std::optional<T>&
>(data) = std::nullopt;
329 (*this)(data.has_value());
330 if (data.has_value()) {
338 template<
class Tuple>
351 std::size_t size = 0;
353 auto&
data_mut =
const_cast<Map&
>(data);
354 for (
size_t i = 0; i < size; ++i) {
355 typename Map::value_type entry;
360 (*this)(data.size());
361 std::for_each(data.begin(), data.end(), std::ref(*
this));
372 std::size_t size = 0;
375 for (
size_t i = 0; i < size; ++i) {
376 typename Set::value_type entry{};
381 (*this)(data.size());
382 std::for_each(data.begin(), data.end(), std::ref(*
this));
386 template<
typename T,
typename...
Args>
387 void variadic_call(T& first,
391 if constexpr (
sizeof...(args) > 0)
392 variadic_call(std::forward<Args>(args)...);
395 template<std::
size_t I = 0,
typename Tuple>
396 typename std::enable_if<I == std::tuple_size<Tuple>::value,
void>::type
397 tuple_call(
const Tuple&)
401 template<std::
size_t I = 0,
typename Tuple>
402 typename std::enable_if<I != std::tuple_size<Tuple>::value,
void>::type
405 (*this)(std::get<I>(
tuple));
419 constexpr static bool value =
false;
422 template<
class T1,
class Allocator>
424 constexpr static bool value =
true;
428 template<
class T1,
class Allocator>
430 constexpr static bool value =
true;
437 constexpr static bool value =
false;
440 template<
class... Ts>
442 constexpr static bool value =
true;
448 constexpr static bool value =
false;
451 template<
class... Ts>
453 constexpr static bool value =
true;
456 template<
class T1,
class T2>
458 constexpr static bool value =
true;
464 constexpr static bool value =
false;
469 constexpr static bool value =
true;
472 template<
class T1,
class Deleter>
473 struct is_ptr<std::unique_ptr<T1, Deleter>> {
474 constexpr static bool value =
true;
480 constexpr static bool value =
false;
485 constexpr static bool value =
true;
491 constexpr static bool value =
false;
494 template<
class Key,
class T,
class Compare,
class Allocator>
496 constexpr static bool value =
true;
499 template<
class Key,
class T,
class Hash,
class KeyEqual,
class Allocator>
501 constexpr static bool value =
true;
507 constexpr static bool value =
false;
510 template<
class Key,
class Compare,
class Allocator>
512 constexpr static bool value =
true;
515 template<
class Key,
class Hash,
class KeyEqual,
class Allocator>
517 constexpr static bool value =
true;
523 constexpr static bool value =
false;
526 template<
class T, std::
size_t N>
528 constexpr static bool value =
true;
532 template<
class T,
int N>
534 constexpr static bool value =
true;
541 template <
typename,
class =
void>
548 template <
typename T>
550 T, std::
void_t<decltype(std::declval<T>().serializeOp(std::declval<Serializer<Packer>&>()))>
551 > :
public std::true_type {};
554 template<
class PtrType>
557 using T1 =
typename PtrType::element_type;
558 std::uintptr_t data_ptr =
reinterpret_cast<std::uintptr_t
>(data.get());
563 if (
m_ptrmap.count(data_ptr) == 0) {
568 if (
m_ptrmap.count(data_ptr) == 0) {
569 const_cast<PtrType&
>(data) = std::make_shared<T1>();
570 m_ptrmap[data_ptr] = std::static_pointer_cast<void>(data);
573 const_cast<PtrType&
>(data) = std::static_pointer_cast<T1>(
m_ptrmap[data_ptr]);
578 template<
class PtrType>
579 void unique_ptr(
const PtrType& data)
581 using T1 =
typename PtrType::element_type;
584 (*this)(data ? 1 : 0);
592 const_cast<PtrType&
>(data) = std::make_unique<T1>();
603 std::map<std::uintptr_t, std::shared_ptr<void>>
m_ptrmap;
Class for (de-)serializing.
Definition Serializer.hpp:91
size_t m_position
Current position in buffer.
Definition Serializer.hpp:601
void array(const Array &data)
Handler for arrays.
Definition Serializer.hpp:277
void operator()(const T &data)
Applies current serialization op to the passed data.
Definition Serializer.hpp:101
bool isSerializing() const
Returns true if we are currently doing a serialization operation.
Definition Serializer.hpp:204
const Packer & m_packer
Packer to use.
Definition Serializer.hpp:598
void tuple(const Tuple &data)
Handler for std::tuple.
Definition Serializer.hpp:339
void set(const Set &data)
Handler for sets.
Definition Serializer.hpp:369
Operation
Enumeration of operations.
Definition Serializer.hpp:410
@ 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:175
void shared_ptr(const PtrType &data)
Handler for shared pointers.
Definition Serializer.hpp:555
size_t position() const
Returns current position in buffer.
Definition Serializer.hpp:198
size_t m_packSize
Required buffer size after PACKSIZE has been done.
Definition Serializer.hpp:600
void pack(const Args &... data)
Call this to serialize data.
Definition Serializer.hpp:157
void unpack(Args &... data)
Call this to de-serialize data.
Definition Serializer.hpp:188
void vector(const Vector &data)
Handler for vectors.
Definition Serializer.hpp:214
void vector(const std::vector< bool > &data)
Handler for bool vectors.
Definition Serializer.hpp:252
Serializer(const Packer &packer)
Constructor.
Definition Serializer.hpp:95
void variant(const std::variant< Args... > &data)
Handler for std::variant.
Definition Serializer.hpp:298
void map(const Map &data)
Handler for maps.
Definition Serializer.hpp:348
void pack(const T &data)
Call this to serialize data.
Definition Serializer.hpp:139
Operation m_op
Current operation.
Definition Serializer.hpp:599
void optional(const std::optional< T > &data)
Handler for std::optional.
Definition Serializer.hpp:316
std::vector< char > m_buffer
Buffer for serialized data.
Definition Serializer.hpp:602
std::map< std::uintptr_t, std::shared_ptr< void > > m_ptrmap
Map to keep track of which pointer data has been serialized and actual pointers during unpacking.
Definition Serializer.hpp:603
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition Exceptions.hpp:30
Detect existence of serializeOp member function.
Definition Serializer.hpp:542
Predicate for arrays.
Definition Serializer.hpp:522
Predicate for maps.
Definition Serializer.hpp:490
Predicate for std::optional.
Definition Serializer.hpp:479
Predicate for detecting pairs and tuples.
Definition Serializer.hpp:447
Predicate for smart pointers.
Definition Serializer.hpp:463
Predicate for sets.
Definition Serializer.hpp:506
Predicate for detecting variants.
Definition Serializer.hpp:436
Predicate for detecting vectors.
Definition Serializer.hpp:418
Definition Serializer.hpp:52
Definition Serializer.hpp:78