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>>;
84constexpr bool is_pod_v = std::is_standard_layout_v<T> && std::is_trivial_v<T>;
127 const_cast<T&
>(data).serializeOp(*
this);
159 template<
class...
Args>
165 variadic_call(data...);
170 variadic_call(data...);
190 template<
class...
Args>
196 variadic_call(data...);
216 template <
typename Vector>
219 if constexpr (detail::is_pod_v<typename Vector::value_type>) {
221 (*this)(data.size());
222 if (data.size() > 0) {
226 (*this)(data.size());
227 if (data.size() > 0) {
231 std::size_t size = 0;
233 auto&
data_mut =
const_cast<Vector&
>(data);
241 std::size_t size = 0;
243 auto&
data_mut =
const_cast<Vector&
>(data);
247 (*this)(data.size());
248 std::for_each(data.begin(), data.end(), std::ref(*
this));
255 void vector(
const std::vector<bool>& data)
258 std::size_t size = 0;
260 auto&
data_mut =
const_cast<std::vector<bool>&
>(data);
263 for (
size_t i = 0; i < size; ++i) {
269 (*this)(data.size());
270 for (
const auto entry : data) {
279 template <
class Array>
282 using T =
typename Array::value_type;
284 if constexpr (detail::is_pod_v<T>) {
290 auto&
data_mut =
const_cast<Array&
>(data);
294 std::for_each(data.begin(), data.end(), std::ref(*
this));
300 template<
class...
Args>
301 void variant(
const std::variant<Args...>& data)
304 std::size_t index = 0;
306 auto&
data_mut =
const_cast<std::variant<
Args...
>&>(data);
308 std::visit(std::ref(*
this),
data_mut);
310 (*this)(data.index());
311 std::visit(std::ref(*
this), data);
327 const_cast<std::optional<T>&
>(data) = res;
329 const_cast<std::optional<T>&
>(data) = std::nullopt;
332 (*this)(data.has_value());
333 if (data.has_value()) {
341 template<
class Tuple>
354 std::size_t size = 0;
357 for (
size_t i = 0; i < size; ++i) {
358 typename Map::value_type entry;
363 (*this)(data.size());
364 std::for_each(data.begin(), data.end(), std::ref(*
this));
375 std::size_t size = 0;
378 for (
size_t i = 0; i < size; ++i) {
379 typename Set::value_type entry{};
384 (*this)(data.size());
385 std::for_each(data.begin(), data.end(), std::ref(*
this));
389 template<
typename T,
typename...
Args>
390 void variadic_call(T& first,
394 if constexpr (
sizeof...(args) > 0)
395 variadic_call(std::forward<Args>(args)...);
398 template<std::
size_t I = 0,
typename Tuple>
399 typename std::enable_if<I == std::tuple_size<Tuple>::value,
void>::type
400 tuple_call(
const Tuple&)
404 template<std::
size_t I = 0,
typename Tuple>
405 typename std::enable_if<I != std::tuple_size<Tuple>::value,
void>::type
408 (*this)(std::get<I>(
tuple));
422 constexpr static bool value =
false;
425 template<
class T1,
class Allocator>
427 constexpr static bool value =
true;
431 template<
class T1,
class Allocator>
433 constexpr static bool value =
true;
440 constexpr static bool value =
false;
443 template<
class... Ts>
445 constexpr static bool value =
true;
451 constexpr static bool value =
false;
454 template<
class... Ts>
456 constexpr static bool value =
true;
459 template<
class T1,
class T2>
461 constexpr static bool value =
true;
467 constexpr static bool value =
false;
472 constexpr static bool value =
true;
475 template<
class T1,
class Deleter>
476 struct is_ptr<std::unique_ptr<T1, Deleter>> {
477 constexpr static bool value =
true;
483 constexpr static bool value =
false;
488 constexpr static bool value =
true;
494 constexpr static bool value =
false;
497 template<
class Key,
class T,
class Compare,
class Allocator>
499 constexpr static bool value =
true;
502 template<
class Key,
class T,
class Hash,
class KeyEqual,
class Allocator>
504 constexpr static bool value =
true;
510 constexpr static bool value =
false;
513 template<
class Key,
class Compare,
class Allocator>
515 constexpr static bool value =
true;
518 template<
class Key,
class Hash,
class KeyEqual,
class Allocator>
520 constexpr static bool value =
true;
526 constexpr static bool value =
false;
529 template<
class T, std::
size_t N>
531 constexpr static bool value =
true;
535 template<
class T,
int N>
537 constexpr static bool value =
true;
544 template <
typename,
class =
void>
551 template <
typename T>
553 T, std::
void_t<decltype(std::declval<T>().serializeOp(std::declval<Serializer<Packer>&>()))>
554 > :
public std::true_type {};
557 template<
class PtrType>
560 using T1 =
typename PtrType::element_type;
561 std::uintptr_t data_ptr =
reinterpret_cast<std::uintptr_t
>(data.get());
566 if (
m_ptrmap.count(data_ptr) == 0) {
571 if (
m_ptrmap.count(data_ptr) == 0) {
572 const_cast<PtrType&
>(data) = std::make_shared<T1>();
573 m_ptrmap[data_ptr] = std::static_pointer_cast<void>(data);
576 const_cast<PtrType&
>(data) = std::static_pointer_cast<T1>(
m_ptrmap[data_ptr]);
581 template<
class PtrType>
582 void unique_ptr(
const PtrType& data)
584 using T1 =
typename PtrType::element_type;
587 (*this)(data ? 1 : 0);
595 const_cast<PtrType&
>(data) = std::make_unique<T1>();
606 std::map<std::uintptr_t, std::shared_ptr<void>>
m_ptrmap;
Class for (de-)serializing.
Definition Serializer.hpp:94
size_t m_position
Current position in buffer.
Definition Serializer.hpp:604
void array(const Array &data)
Handler for arrays.
Definition Serializer.hpp:280
void operator()(const T &data)
Applies current serialization op to the passed data.
Definition Serializer.hpp:104
bool isSerializing() const
Returns true if we are currently doing a serialization operation.
Definition Serializer.hpp:207
const Packer & m_packer
Packer to use.
Definition Serializer.hpp:601
void tuple(const Tuple &data)
Handler for std::tuple.
Definition Serializer.hpp:342
void set(const Set &data)
Handler for sets.
Definition Serializer.hpp:372
Operation
Enumeration of operations.
Definition Serializer.hpp:413
@ 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:178
void shared_ptr(const PtrType &data)
Handler for shared pointers.
Definition Serializer.hpp:558
size_t position() const
Returns current position in buffer.
Definition Serializer.hpp:201
size_t m_packSize
Required buffer size after PACKSIZE has been done.
Definition Serializer.hpp:603
void pack(const Args &... data)
Call this to serialize data.
Definition Serializer.hpp:160
void unpack(Args &... data)
Call this to de-serialize data.
Definition Serializer.hpp:191
void vector(const Vector &data)
Handler for vectors.
Definition Serializer.hpp:217
void vector(const std::vector< bool > &data)
Handler for bool vectors.
Definition Serializer.hpp:255
Serializer(const Packer &packer)
Constructor.
Definition Serializer.hpp:98
void variant(const std::variant< Args... > &data)
Handler for std::variant.
Definition Serializer.hpp:301
void map(const Map &data)
Handler for maps.
Definition Serializer.hpp:351
void pack(const T &data)
Call this to serialize data.
Definition Serializer.hpp:142
Operation m_op
Current operation.
Definition Serializer.hpp:602
void optional(const std::optional< T > &data)
Handler for std::optional.
Definition Serializer.hpp:319
std::vector< char > m_buffer
Buffer for serialized data.
Definition Serializer.hpp:605
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:606
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:545
Predicate for arrays.
Definition Serializer.hpp:525
Predicate for maps.
Definition Serializer.hpp:493
Predicate for std::optional.
Definition Serializer.hpp:482
Predicate for detecting pairs and tuples.
Definition Serializer.hpp:450
Predicate for smart pointers.
Definition Serializer.hpp:466
Predicate for sets.
Definition Serializer.hpp:509
Predicate for detecting variants.
Definition Serializer.hpp:439
Predicate for detecting vectors.
Definition Serializer.hpp:421
Definition Serializer.hpp:52
Definition Serializer.hpp:78