33#include <unordered_map>
34#include <unordered_set>
39namespace Dune {
template<
typename,
int>
class FieldVector; }
43namespace Dune {
template<
typename,
typename>
class BlockVector; }
49template<
typename ...Ts>
53template<std::size_t Index,
typename,
typename ...Rest>
54static decltype(
auto) make_variant(std::size_t index)
57 return std::variant<Ts...>{std::in_place_index_t<Index>{}};
59 if constexpr(
sizeof...(Rest) != 0)
60 return make_variant<Index + 1, Rest...>(index);
62 throw std::runtime_error(
"Invalid variant index");
67template<
typename ...Ts>
68decltype(
auto) make_variant(std::size_t index)
74using remove_cvr_t = std::remove_cv_t<std::remove_reference_t<T>>;
113 const_cast<T&
>(data).serializeOp(*
this);
142 template<
class...
Args>
147 variadic_call(data...);
151 variadic_call(data...);
168 template<
class...
Args>
173 variadic_call(data...);
190 template<
typename Vector>
193 if (data.size() == 0)
200 template<
typename Vector>
203 if (data.size() == 0)
211 template <
typename Vector>
214 if constexpr (std::is_pod_v<typename Vector::value_type>) {
216 (*this)(data.size());
219 (*this)(data.size());
222 std::size_t size = 0;
224 auto&
data_mut =
const_cast<Vector&
>(data);
230 std::size_t size = 0;
232 auto&
data_mut =
const_cast<Vector&
>(data);
236 (*this)(data.size());
237 std::for_each(data.begin(), data.end(), std::ref(*
this));
244 void vector(
const std::vector<bool>& data)
247 std::size_t size = 0;
249 auto&
data_mut =
const_cast<std::vector<bool>&
>(data);
252 for (
size_t i = 0; i < size; ++i) {
258 (*this)(data.size());
259 for (
const auto entry : data) {
268 template <
class Array>
271 using T =
typename Array::value_type;
273 if constexpr (std::is_pod_v<T>) {
279 auto&
data_mut =
const_cast<Array&
>(data);
283 std::for_each(data.begin(), data.end(), std::ref(*
this));
289 template<
class...
Args>
290 void variant(
const std::variant<Args...>& data)
293 std::size_t index = 0;
295 auto&
data_mut =
const_cast<std::variant<
Args...
>&>(data);
297 std::visit(std::ref(*
this),
data_mut);
299 (*this)(data.index());
300 std::visit(std::ref(*
this), data);
316 const_cast<std::optional<T>&
>(data) = res;
319 (*this)(data.has_value());
320 if (data.has_value()) {
328 template<
class Tuple>
341 std::size_t size = 0;
343 auto&
data_mut =
const_cast<Map&
>(data);
344 for (
size_t i = 0; i < size; ++i) {
345 typename Map::value_type entry;
350 (*this)(data.size());
351 std::for_each(data.begin(), data.end(), std::ref(*
this));
362 std::size_t size = 0;
365 for (
size_t i = 0; i < size; ++i) {
366 typename Set::value_type entry;
371 (*this)(data.size());
372 std::for_each(data.begin(), data.end(), std::ref(*
this));
376 template<
typename T,
typename...
Args>
377 void variadic_call(T& first,
381 if constexpr (
sizeof...(args) > 0)
382 variadic_call(std::forward<Args>(args)...);
385 template<std::
size_t I = 0,
typename Tuple>
386 typename std::enable_if<I == std::tuple_size<Tuple>::value,
void>::type
387 tuple_call(
const Tuple&)
391 template<std::
size_t I = 0,
typename Tuple>
392 typename std::enable_if<I != std::tuple_size<Tuple>::value,
void>::type
395 (*this)(std::get<I>(
tuple));
409 constexpr static bool value =
false;
412 template<
class T1,
class Allocator>
414 constexpr static bool value =
true;
418 template<
class T1,
class Allocator>
420 constexpr static bool value =
true;
427 constexpr static bool value =
false;
430 template<
class... Ts>
432 constexpr static bool value =
true;
438 constexpr static bool value =
false;
441 template<
class... Ts>
443 constexpr static bool value =
true;
446 template<
class T1,
class T2>
448 constexpr static bool value =
true;
454 constexpr static bool value =
false;
459 constexpr static bool value =
true;
462 template<
class T1,
class Deleter>
464 constexpr static bool value =
true;
470 constexpr static bool value =
false;
475 constexpr static bool value =
true;
481 constexpr static bool value =
false;
484 template<
class Key,
class T,
class Compare,
class Allocator>
486 constexpr static bool value =
true;
489 template<
class Key,
class T,
class Hash,
class KeyEqual,
class Allocator>
491 constexpr static bool value =
true;
497 constexpr static bool value =
false;
500 template<
class Key,
class Compare,
class Allocator>
502 constexpr static bool value =
true;
505 template<
class Key,
class Hash,
class KeyEqual,
class Allocator>
507 constexpr static bool value =
true;
513 constexpr static bool value =
false;
516 template<
class T, std::
size_t N>
518 constexpr static bool value =
true;
522 template<
class T,
int N>
524 constexpr static bool value =
true;
531 template <
typename,
class =
void>
538 template <
typename T>
540 T, std::
void_t<decltype(std::declval<T>().serializeOp(std::declval<Serializer<Packer>&>()))>
541 > :
public std::true_type {};
544 template<
class PtrType>
547 using T1 =
typename PtrType::element_type;
548 bool value = data ?
true :
false;
551 const_cast<PtrType&
>(data).reset(
new T1);
Class for (de-)serializing.
Definition Serializer.hpp:84
void ptr(const PtrType &data)
Handler for smart pointers.
Definition Serializer.hpp:545
void array(const Array &data)
Handler for arrays.
Definition Serializer.hpp:269
void operator()(const T &data)
Applies current serialization op to the passed data.
Definition Serializer.hpp:94
bool isSerializing() const
Returns true if we are currently doing a serialization operation.
Definition Serializer.hpp:183
const Packer & m_packer
Packer to use.
Definition Serializer.hpp:558
void tuple(const Tuple &data)
Handler for std::tuple.
Definition Serializer.hpp:329
void set(const Set &data)
Handler for sets.
Definition Serializer.hpp:359
Operation
Enumeration of operations.
Definition Serializer.hpp:400
@ 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:158
size_t position() const
Returns current position in buffer.
Definition Serializer.hpp:177
const Vector::value_type * getVectorData(const Vector &data)
Utility function for missing data() member function in FieldVector of DUNE 2.6.
Definition Serializer.hpp:191
size_t m_packSize
Required buffer size after PACKSIZE has been done.
Definition Serializer.hpp:560
void pack(const Args &... data)
Call this to serialize data.
Definition Serializer.hpp:143
void unpack(Args &... data)
Call this to de-serialize data.
Definition Serializer.hpp:169
void vector(const Vector &data)
Handler for vectors.
Definition Serializer.hpp:212
void vector(const std::vector< bool > &data)
Handler for bool vectors.
Definition Serializer.hpp:244
Serializer(const Packer &packer)
Constructor.
Definition Serializer.hpp:88
void variant(const std::variant< Args... > &data)
Handler for std::variant.
Definition Serializer.hpp:290
Vector::value_type * getVectorData(Vector &data)
Utility function for missing data() member function in FieldVector of DUNE 2.6.
Definition Serializer.hpp:201
void map(const Map &data)
Handler for maps.
Definition Serializer.hpp:338
void pack(const T &data)
Call this to serialize data.
Definition Serializer.hpp:128
Operation m_op
Current operation.
Definition Serializer.hpp:559
void optional(const std::optional< T > &data)
Handler for std::optional.
Definition Serializer.hpp:308
int m_position
Current position in buffer.
Definition Serializer.hpp:561
std::vector< char > m_buffer
Buffer for serialized data.
Definition Serializer.hpp:562
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:532
Predicate for arrays.
Definition Serializer.hpp:512
Predicate for maps.
Definition Serializer.hpp:480
Predicate for std::optional.
Definition Serializer.hpp:469
Predicate for detecting pairs and tuples.
Definition Serializer.hpp:437
Predicate for smart pointers.
Definition Serializer.hpp:453
Predicate for sets.
Definition Serializer.hpp:496
Predicate for detecting variants.
Definition Serializer.hpp:426
Predicate for detecting vectors.
Definition Serializer.hpp:408
Definition Serializer.hpp:51