PUP namespace

Extensions to Charm++'s Pack/Unpack routines.

Functions

template<typename E, typename std::enable_if<std::is_enum<E>::value, int>::type = 0>
void pup(PUP::er& p, E& e)
Pack/Unpack enum class.
template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>>
void pup(PUP::er& p, std::unordered_map<Key, T, Hash, KeyEqual>& m)
template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>>
void operator|(PUP::er& p, std::unordered_map<Key, T, Hash, KeyEqual>& m)
template<class Key, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>>
void pup(PUP::er& p, std::unordered_set<Key, Hash, KeyEqual>& s)
template<class Key, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>>
void operator|(PUP::er& p, std::unordered_set<Key, Hash, KeyEqual>& s)
template<class T>
void pup(PUP::er& p, std::optional<T>& o)
template<class T>
void operator|(PUP::er& p, std::optional<T>& o)
template<class T, class... Ts>
auto pup_helper(std::size_t& index, const std::size_t send_index, PUP::er& p, std::variant<Ts...>& var) -> char
template<class... Ts>
void pup(PUP::er& p, std::variant<Ts...>& var)
template<typename... Ts>
void operator|(PUP::er& p, std::variant<Ts...>& d)

Charm++ pack/unpack serializer member functions for Refinement_State

void pup(PUP::er& p, AMR::Refinement_State& s)
void operator|(PUP::er& p, AMR::Refinement_State& s)

Charm++ pack/unpack serializer member functions for Edge_Refinement

void pup(PUP::er& p, AMR::Edge_Refinement& e)
void operator|(PUP::er& p, AMR::Edge_Refinement& e)

Charm++ pack/unpack serializer member functions for edge_store_t

void pup(PUP::er& p, AMR::edge_store_t& e)
void operator|(PUP::er& p, AMR::edge_store_t& e)

Charm++ pack/unpack serializer member functions for edge_t

void pup(PUP::er& p, AMR::edge_t& e)
void operator|(PUP::er& p, AMR::edge_t& e)

Charm++ pack/unpack serializer member functions for marked_refinements_store_t

template<class case_t>
void pup(PUP::er& p, AMR::marked_refinements_store_t<case_t>& m)
template<class case_t>
void operator|(PUP::er& p, AMR::marked_refinements_store_t<case_t>& m)

Charm++ pack/unpack serializer member functions for active_element_store_t

void pup(PUP::er& p, AMR::active_element_store_t& a)
void operator|(PUP::er& p, AMR::active_element_store_t& a)
void pup(PUP::er& p, AMR::id_generator_t& i)
void operator|(PUP::er& p, AMR::id_generator_t& i)

Charm++ pack/unpack serializer member functions for master_element_store_t

void pup(PUP::er& p, AMR::master_element_store_t& m)
void operator|(PUP::er& p, AMR::master_element_store_t& m)

Charm++ pack/unpack serializer member functions for tet_store_t

void pup(PUP::er& p, AMR::tet_store_t& t)
void operator|(PUP::er& p, AMR::tet_store_t& t)

Charm++ pack/unpack serializer member functions for mesh_adapter_t

void pup(PUP::er& p, AMR::mesh_adapter_t& m)
void operator|(PUP::er& p, AMR::mesh_adapter_t& m)

Charm++ pack/unpack serializer member functions for node_store_t

void pup(PUP::er& p, AMR::node_store_t& n)
void operator|(PUP::er& p, AMR::node_store_t& n)

Charm++ pack/unpack serializer member functions for node_connectivity_t

void pup(PUP::er& p, AMR::node_connectivity_t& n)
void operator|(PUP::er& p, AMR::node_connectivity_t& n)

Charm++ pack/unpack serializer member functions for refinement_t

void pup(PUP::er& p, AMR::refinement_t& r)
void operator|(PUP::er& p, AMR::refinement_t& r)

Function documentation

#include <src/Base/PUPUtil.hpp>
template<typename E, typename std::enable_if<std::is_enum<E>::value, int>::type = 0>
void PUP::pup(PUP::er& p, E& e)

Pack/Unpack enum class.

Parameters
p in Charm++'s pack/unpack object
e in Enum class to pack/unpack

In Charm++ usually both the pup() overload and an overload for operator| are defined for all serializable types. However, we cannot define operator| for enum class as it would conflict with Charm++'s catch-all, template< class T > inline void operator|(PUP::er &p,T &t) {...}.

#include <src/Base/PUPUtil.hpp>
template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>>
void PUP::pup(PUP::er& p, std::unordered_map<Key, T, Hash, KeyEqual>& m)

Parameters
p in Charm++'s pack/unpack object
m in std::unordered_map< Key, T, Hash, KeyEqual > to pack/unpack

Pack/Unpack std::unordered_map.

#include <src/Base/PUPUtil.hpp>
template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>>
void PUP::operator|(PUP::er& p, std::unordered_map<Key, T, Hash, KeyEqual>& m)

Parameters
p in Charm++'s pack/unpack object
m in std::unordered_map< Key, T, Hash, KeyEqual > to pack/unpack

Pack/Unpack std::unordered_map.

#include <src/Base/PUPUtil.hpp>
template<class Key, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>>
void PUP::pup(PUP::er& p, std::unordered_set<Key, Hash, KeyEqual>& s)

Parameters
p in Charm++'s pack/unpack object
s in std::unordered_set< Key, Hash, KeyEqual > to pack/unpack

Pack/Unpack std::unordered_set.

#include <src/Base/PUPUtil.hpp>
template<class Key, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>>
void PUP::operator|(PUP::er& p, std::unordered_set<Key, Hash, KeyEqual>& s)

Parameters
p in Charm++'s pack/unpack object
s in std::unordered_set< Key, Hash, KeyEqual > to pack/unpack

Pack/Unpack std::unordered_set.

#include <src/Base/PUPUtil.hpp>
template<class T>
void PUP::pup(PUP::er& p, std::optional<T>& o)

Parameters
p in Charm++'s pack/unpack object
o in std::optional< T > of arbitrary type T to pack/unpack

Pack/Unpack std::optional

#include <src/Base/PUPUtil.hpp>
template<class T>
void PUP::operator|(PUP::er& p, std::optional<T>& o)

Parameters
p in Charm++'s pack/unpack object
o in std::optional< T > of arbitrary type T to pack/unpack

Pack/Unpack std::optional

#include <src/Base/PUPUtil.hpp>
template<class T, class... Ts>
char PUP::pup_helper(std::size_t& index, const std::size_t send_index, PUP::er& p, std::variant<Ts...>& var)

Parameters
index in/out Counter (location) for type in variant
send_index in Target counter (location) for type in variant
p in Charm++'s pack/unpack object
var in std::variant< Ts... > of arbitrary types to pack/unpack

Pack/Unpack helper for std::variant

#include <src/Base/PUPUtil.hpp>
template<class... Ts>
void PUP::pup(PUP::er& p, std::variant<Ts...>& var)

Parameters
p in Charm++'s pack/unpack object
var in std::variant< Ts... > of arbitrary types to pack/unpack

Pack/Unpack std::variant

#include <src/Base/PUPUtil.hpp>
template<typename... Ts>
void PUP::operator|(PUP::er& p, std::variant<Ts...>& d)

Parameters
p in Charm++'s pack/unpack object
d in std::variant< Ts... > of arbitrary types to pack/unpack

Pack/Unpack std::variant

void PUP::pup(PUP::er& p, AMR::Refinement_State& s)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in Charm++'s pack/unpack object
s in/out Refinement_State object reference

Pack/Unpack Refinement_State

void PUP::operator|(PUP::er& p, AMR::Refinement_State& s)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in/out Charm++'s PUP::er serializer object reference
s in/out Refinement_State object reference

Pack/Unpack serialize operator|

void PUP::pup(PUP::er& p, AMR::Edge_Refinement& e)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in Charm++'s pack/unpack object
e in/out Edge_Refinement object reference

Pack/Unpack Edge_Refinement

void PUP::operator|(PUP::er& p, AMR::Edge_Refinement& e)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in/out Charm++'s PUP::er serializer object reference
e in/out Edge_Refinement object reference

Pack/Unpack serialize operator|

void PUP::pup(PUP::er& p, AMR::edge_store_t& e)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in Charm++'s pack/unpack object
e in/out edge_store_t object reference

Pack/Unpack edge_store_t

void PUP::operator|(PUP::er& p, AMR::edge_store_t& e)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in/out Charm++'s PUP::er serializer object reference
e in/out edge_store_t object reference

Pack/Unpack serialize operator|

void PUP::pup(PUP::er& p, AMR::edge_t& e)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in Charm++'s pack/unpack object
e in/out edge_t object reference

Pack/Unpack edge_t

void PUP::operator|(PUP::er& p, AMR::edge_t& e)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in/out Charm++'s PUP::er serializer object reference
e in/out edge_t object reference

Pack/Unpack serialize operator|

#include <src/Inciter/PUPAMR.hpp>
template<class case_t>
void PUP::pup(PUP::er& p, AMR::marked_refinements_store_t<case_t>& m)

Parameters
p in Charm++'s pack/unpack object
m in/out marked_refinements_store_t object reference

Pack/Unpack marked_refinements_store_t

#include <src/Inciter/PUPAMR.hpp>
template<class case_t>
void PUP::operator|(PUP::er& p, AMR::marked_refinements_store_t<case_t>& m)

Parameters
p in/out Charm++'s PUP::er serializer object reference
m in/out marked_refinements_store_t object reference

Pack/Unpack serialize operator|

void PUP::pup(PUP::er& p, AMR::active_element_store_t& a)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in Charm++'s pack/unpack object
a in/out active_element_store_t object reference

Pack/Unpack active_element_store_t

void PUP::operator|(PUP::er& p, AMR::active_element_store_t& a)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in/out Charm++'s PUP::er serializer object reference
a in/out active_element_store_t object reference

Pack/Unpack serialize operator|

void PUP::pup(PUP::er& p, AMR::id_generator_t& i)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in Charm++'s pack/unpack object
i in/out id_generator_t object reference

Pack/Unpack id_generator_t

void PUP::operator|(PUP::er& p, AMR::id_generator_t& i)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in/out Charm++'s PUP::er serializer object reference
i in/out id_generator_t object reference

Pack/Unpack serialize operator|

void PUP::pup(PUP::er& p, AMR::master_element_store_t& m)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in Charm++'s pack/unpack object
m in/out master_element_store_t object reference

Pack/Unpack master_element_store_t

void PUP::operator|(PUP::er& p, AMR::master_element_store_t& m)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in/out Charm++'s PUP::er serializer object reference
m in/out master_element_store_t object reference

Pack/Unpack serialize operator|

void PUP::pup(PUP::er& p, AMR::tet_store_t& t)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in Charm++'s pack/unpack object
t in/out tet_store_t object reference

Pack/Unpack tet_store_t

void PUP::operator|(PUP::er& p, AMR::tet_store_t& t)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in/out Charm++'s PUP::er serializer object reference
t in/out tet_store_t object reference

Pack/Unpack serialize operator|

void PUP::pup(PUP::er& p, AMR::mesh_adapter_t& m)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in Charm++'s pack/unpack object
m in/out mesh_adapter_t object reference

Pack/Unpack mesh_adapter_t

void PUP::operator|(PUP::er& p, AMR::mesh_adapter_t& m)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in/out Charm++'s PUP::er serializer object reference
m in/out mesh_adapter_t object reference

Pack/Unpack serialize operator|

void PUP::pup(PUP::er& p, AMR::node_store_t& n)
#include <src/Inciter/PUPAMR.hpp>

Pack/Unpack node_store_t

void PUP::operator|(PUP::er& p, AMR::node_store_t& n)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in/out Charm++'s PUP::er serializer object reference
n in/out node_store_t object reference

Pack/Unpack serialize operator|

void PUP::pup(PUP::er& p, AMR::node_connectivity_t& n)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in Charm++'s pack/unpack object
n in/out node_connectivity_t object reference

Pack/Unpack node_connectivity_t

void PUP::operator|(PUP::er& p, AMR::node_connectivity_t& n)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in/out Charm++'s PUP::er serializer object reference
n in/out node_connectivity_t object reference

Pack/Unpack serialize operator|

void PUP::pup(PUP::er& p, AMR::refinement_t& r)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in Charm++'s pack/unpack object
r in/out refinement_t object reference

Pack/Unpack refinement_t

void PUP::operator|(PUP::er& p, AMR::refinement_t& r)
#include <src/Inciter/PUPAMR.hpp>

Parameters
p in/out Charm++'s PUP::er serializer object reference
r in/out refinement_t object reference

Pack/Unpack serialize operator|