serialization

The contents of this module can be included with the header hpx/modules/serialization.hpp. These headers may be used by user-code but are not guaranteed stable (neither header location nor contents). You are using these at your own risk. If you wish to use non-public functionality from a module we strongly suggest only including the module header hpx/modules/serialization.hpp, not the particular header in which the functionality you would like to use is defined. See Public API for a list of names that are part of the public HPX API.

template<typename T>
struct serialize_non_intrusive<T, typename std::enable_if<has_serialize_adl<T>::value>::type>

Public Static Functions

template<typename Archive>
static void call(Archive &ar, T &t, unsigned)

namespace hpx

namespace serialization

class access

Public Static Functions

template<class Archive, class T>
static void serialize(Archive &ar, T &t, unsigned)

template<typename Archive, typename T>
static void save_base_object(Archive &ar, T const &t, unsigned)

template<typename Archive, typename T>
static void load_base_object(Archive &ar, T &t, unsigned)

template<typename T>
static std::string get_name(T const *t)

template<class T>
class has_serialize

Public Static Attributes

constexpr bool value = decltype(test<T>(0))::value

Private Static Functions

template<class T1>
static std::false_type test(...)

template<class T1, class = decltype(std::declval<typename std::remove_const<T1>::type&>().serialize(std::declval<output_archive&>(), 0u))>
static std::true_type test(int)

template<class T>
class serialize_dispatcher

Public Types

template<>
using type = typename std::conditional::type

struct empty

Public Static Functions

template<class Archive>
static void call(Archive&, T&, unsigned)

struct intrusive_polymorphic

Public Static Functions

template<>
static void call(hpx::serialization::input_archive &ar, T &t, unsigned)

template<>
static void call(hpx::serialization::output_archive &ar, T const &t, unsigned)

struct intrusive_usual

Public Static Functions

template<class Archive>
static void call(Archive &ar, T &t, unsigned)

struct non_intrusive

Public Static Functions

template<class Archive>
static void call(Archive &ar, T &t, unsigned)

template<typename T>
class has_serialize_adl

Public Static Attributes

constexpr bool value = decltype(test<T>(0))::value

Private Static Functions

template<typename T1>
static std::false_type test(...)

template<typename T1, typename = decltype(serialize(std::declval<hpx::serialization::output_archive&>(), std::declval<typename std::remove_const<T1>::type&>(), 0u))>
static std::true_type test(int)

template<typename T>
struct serialize_non_intrusive<T, typename std::enable_if<has_serialize_adl<T>::value>::type>

Public Static Functions

template<typename Archive>
static void call(Archive &ar, T &t, unsigned)

namespace hpx

namespace serialization

Functions

template<class T>
array<T> make_array(T *begin, std::size_t size)

template<typename Archive, typename T, std::size_t N>
void serialize(Archive &ar, std::array<T, N> &a, const unsigned int)

template<typename T>
output_archive &operator<<(output_archive &ar, array<T> t)

template<typename T>
input_archive &operator>>(input_archive &ar, array<T> t)

template<typename T>
output_archive &operator&(output_archive &ar, array<T> t)

template<typename T>
input_archive &operator&(input_archive &ar, array<T> t)

template<typename T, std::size_t N>
output_archive &operator<<(output_archive &ar, T (&t)[N])

template<typename T, std::size_t N>
input_archive &operator>>(input_archive &ar, T (&t)[N])

template<typename T, std::size_t N>
output_archive &operator&(output_archive &ar, T (&t)[N])

template<typename T, std::size_t N>
input_archive &operator&(input_archive &ar, T (&t)[N])

template<class T>
class array

Public Types

template<>
using value_type = T

Public Functions

array(value_type *t, std::size_t s)

value_type *address() const

std::size_t count() const

template<class Archive>
void serialize_optimized(Archive &ar, unsigned int, std::false_type)

void serialize_optimized(output_archive &ar, unsigned int, std::true_type)

void serialize_optimized(input_archive &ar, unsigned int, std::true_type)

template<class Archive>
void serialize(Archive &ar, unsigned int v)

Private Members

value_type *m_t

std::size_t m_element_count

template<typename Derived, typename Base>
struct base_object_type<Derived, Base, std::true_type>

Public Functions

base_object_type(Derived &d)

template<class Archive>
void save(Archive &ar, unsigned) const

template<class Archive>
void load(Archive &ar, unsigned)

HPX_SERIALIZATION_SPLIT_MEMBER()

Public Members

Derived &d_

namespace hpx

namespace serialization

Functions

template<typename Base, typename Derived>
base_object_type<Derived, Base> base_object(Derived &d)

template<typename D, typename B>
output_archive &operator<<(output_archive &ar, base_object_type<D, B> t)

template<typename D, typename B>
input_archive &operator>>(input_archive &ar, base_object_type<D, B> t)

template<typename D, typename B>
output_archive &operator&(output_archive &ar, base_object_type<D, B> t)

template<typename D, typename B>
input_archive &operator&(input_archive &ar, base_object_type<D, B> t)

template<typename Derived, typename Base, typename Enable = typename hpx::traits::is_intrusive_polymorphic<Derived>::type>
struct base_object_type

Public Functions

base_object_type(Derived &d)

template<typename Archive>
void serialize(Archive &ar, unsigned)

Public Members

Derived &d_

template<typename Derived, typename Base>
struct base_object_type<Derived, Base, std::true_type>

Public Functions

base_object_type(Derived &d)

template<class Archive>
void save(Archive &ar, unsigned) const

template<class Archive>
void load(Archive &ar, unsigned)

HPX_SERIALIZATION_SPLIT_MEMBER()

Public Members

Derived &d_

namespace hpx

namespace serialization

Enums

enum archive_flags

Values:

no_archive_flags = 0x00000000

enable_compression = 0x00002000

endian_big = 0x00004000

endian_little = 0x00008000

disable_array_optimization = 0x00010000

disable_data_chunking = 0x00020000

all_archive_flags = 0x0003e000

Functions

void reverse_bytes(std::size_t size, char *address)

template<typename Archive>
void save_binary(Archive &ar, void const *address, std::size_t count)

template<typename Archive>
void load_binary(Archive &ar, void *address, std::size_t count)

template<typename Archive>
std::size_t current_pos(const Archive &ar)

template<typename Archive>
struct basic_archive

Public Functions

virtual ~basic_archive()

template<typename T>
void invoke(T &t)

bool enable_compression() const

bool endian_big() const

bool endian_little() const

bool disable_array_optimization() const

bool disable_data_chunking() const

std::uint32_t flags() const

bool is_preprocessing() const

std::size_t current_pos() const

void save_binary(void const *address, std::size_t count)

void load_binary(void *address, std::size_t count)

void reset()

template<typename T>
T &get_extra_data()

template<typename T>
T *try_get_extra_data()

Public Static Attributes

const std::uint64_t npos = std::uint64_t(-1)

Protected Functions

basic_archive(std::uint32_t flags)

basic_archive(basic_archive const&)

basic_archive &operator=(basic_archive const&)

Protected Attributes

std::uint32_t flags_

std::size_t size_

detail::extra_archive_data extra_data_

namespace hpx

namespace serialization

struct binary_filter

Public Functions

virtual void set_max_length(std::size_t size) = 0

virtual void save(void const *src, std::size_t src_count) = 0

virtual bool flush(void *dst, std::size_t dst_count, std::size_t &written) = 0

virtual std::size_t init_data(char const *buffer, std::size_t size, std::size_t buffer_size) = 0

virtual void load(void *dst, std::size_t dst_count) = 0

template<class T>
void serialize(T&, unsigned)

HPX_SERIALIZATION_POLYMORPHIC_ABSTRACT(binary_filter)

virtual ~binary_filter()

namespace hpx

namespace serialization

Functions

template<std::size_t N>
void serialize(input_archive &ar, std::bitset<N> &d, unsigned)

template<std::size_t N>
void serialize(output_archive &ar, std::bitset<N> const &bs, unsigned)

namespace hpx

namespace serialization

Functions

template<typename T>
void serialize(input_archive &ar, std::complex<T> &c, unsigned)

template<typename T>
void serialize(output_archive &ar, std::complex<T> const &c, unsigned)

namespace hpx

namespace serialization

struct erased_input_container

Subclassed by hpx::serialization::input_container< Container >

Public Functions

virtual ~erased_input_container()

virtual bool is_preprocessing() const

virtual void set_filter(binary_filter *filter) = 0

virtual void load_binary(void *address, std::size_t count) = 0

virtual void load_binary_chunk(void *address, std::size_t count) = 0

struct erased_output_container

Subclassed by hpx::serialization::output_container< Container, Chunker >

Public Functions

virtual ~erased_output_container()

virtual bool is_preprocessing() const

virtual void set_filter(binary_filter *filter) = 0

virtual void save_binary(void const *address, std::size_t count) = 0

virtual std::size_t save_binary_chunk(void const *address, std::size_t count) = 0

virtual void reset() = 0

virtual std::size_t get_num_chunks() const = 0

virtual void flush() = 0

namespace hpx

namespace serialization

Functions

template<typename T, typename Allocator>
void serialize(input_archive &ar, std::deque<T, Allocator> &d, unsigned)

template<typename T, typename Allocator>
void serialize(output_archive &ar, std::deque<T, Allocator> const &d, unsigned)

namespace hpx

namespace serialization

Functions

template<typename Archive>
void save(Archive &ar, std::exception_ptr const &e, unsigned int)

template<typename Archive>
void load(Archive &ar, std::exception_ptr &e, unsigned int)

namespace util

Enums

enum exception_type

Values:

unknown_exception = 0

std_runtime_error = 1

std_invalid_argument = 2

std_out_of_range = 3

std_logic_error = 4

std_bad_alloc = 5

std_bad_cast = 6

std_bad_typeid = 7

std_bad_exception = 8

std_exception = 9

boost_system_error = 10

hpx_exception = 11

hpx_thread_interrupted_exception = 12

std_system_error = 14

namespace hpx

namespace serialization

struct input_archive : public hpx::serialization::basic_archive<input_archive>

Public Types

using base_type = basic_archive<input_archive>

Public Functions

template<typename Container>
input_archive(Container &buffer, std::size_t inbound_data_size = 0, const std::vector<serialization_chunk> *chunks = nullptr)

template<typename T>
void invoke_impl(T &t)

template<typename T>
std::enable_if<!std::is_integral<T>::value && !std::is_enum<T>::value>::type load(T &t)

template<typename T>
std::enable_if<std::is_integral<T>::value || std::is_enum<T>::value>::type load(T &t)

void load(float &f)

void load(double &d)

void load(char &c)

void load(bool &b)

std::size_t bytes_read() const

std::size_t current_pos() const

Private Functions

template<typename T>
void load_bitwise(T &t, std::false_type)

template<typename T>
void load_bitwise(T &t, std::true_type)

template<class T>
void load_nonintrusively_polymorphic(T &t, std::false_type)

template<class T>
void load_nonintrusively_polymorphic(T &t, std::true_type)

template<typename T>
void load_integral(T &val, std::false_type)

template<typename T>
void load_integral(T &val, std::true_type)

template<class Promoted>
void load_integral_impl(Promoted &l)

void load_binary(void *address, std::size_t count)

void load_binary_chunk(void *address, std::size_t count)

Private Members

std::unique_ptr<erased_input_container> buffer_

Friends

friend hpx::serialization::basic_archive< input_archive >

friend hpx::serialization::array

namespace hpx

namespace serialization

template<typename Container>
struct input_container : public hpx::serialization::erased_input_container

Public Functions

input_container(Container const &cont, std::size_t inbound_data_size)

input_container(Container const &cont, std::vector<serialization_chunk> const *chunks, std::size_t inbound_data_size)

void set_filter(binary_filter *filter)

void load_binary(void *address, std::size_t count)

void load_binary_chunk(void *address, std::size_t count)

Public Members

Container const &cont_

std::size_t current_

std::unique_ptr<binary_filter> filter_

std::size_t decompressed_size_

std::vector<serialization_chunk> const *chunks_

std::size_t current_chunk_

std::size_t current_chunk_size_

Private Types

template<>
using access_traits = traits::serialization_access_data<Container>

Private Functions

std::size_t get_chunk_size(std::size_t chunk) const

std::uint8_t get_chunk_type(std::size_t chunk) const

chunk_data get_chunk_data(std::size_t chunk) const

std::size_t get_num_chunks() const

namespace hpx

namespace serialization

Functions

template<typename T, typename Allocator>
void serialize(input_archive &ar, std::list<T, Allocator> &ls, unsigned)

template<typename T, typename Allocator>
void serialize(output_archive &ar, const std::list<T, Allocator> &ls, unsigned)

namespace hpx

namespace serialization

Functions

template<typename Key, typename Value>
void serialize(input_archive &ar, std::pair<Key, Value> &t, unsigned)

template<typename Key, typename Value>
void serialize(output_archive &ar, const std::pair<Key, Value> &t, unsigned)

template<typename Key, typename Value, typename Comp, typename Alloc>
void serialize(input_archive &ar, std::map<Key, Value, Comp, Alloc> &t, unsigned)

template<typename Key, typename Value, typename Comp, typename Alloc>
void serialize(output_archive &ar, std::map<Key, Value, Comp, Alloc> const &t, unsigned)

namespace hpx

namespace serialization

Functions

template<typename T>
void save(output_archive &ar, hpx::util::optional<T> const &o, unsigned)

template<typename T>
void load(input_archive &ar, hpx::util::optional<T> &o, unsigned)

hpx::serialization::HPX_SERIALIZATION_SPLIT_FREE_TEMPLATE((template< typename T >), (hpx::util::optional< T >))

namespace hpx

namespace serialization

struct output_archive : public hpx::serialization::basic_archive<output_archive>

Public Types

using base_type = basic_archive<output_archive>

Public Functions

template<typename Container>
output_archive(Container &buffer, std::uint32_t flags = 0U, std::vector<serialization_chunk> *chunks = nullptr, binary_filter *filter = nullptr)

std::size_t bytes_written() const

std::size_t get_num_chunks() const

std::size_t current_pos() const

void reset()

void flush()

bool is_preprocessing() const

Protected Functions

template<typename T>
void invoke_impl(T const &t)

template<typename T>
std::enable_if<!std::is_integral<T>::value && !std::is_enum<T>::value>::type save(T const &t)

template<typename T>
std::enable_if<std::is_integral<T>::value || std::is_enum<T>::value>::type save(T t)

void save(float f)

void save(double d)

void save(char c)

void save(bool b)

template<typename T>
void save_bitwise(T const &t, std::false_type)

template<typename T>
void save_bitwise(T const &t, std::true_type)

template<typename T>
void save_nonintrusively_polymorphic(T const &t, std::false_type)

template<typename T>
void save_nonintrusively_polymorphic(T const &t, std::true_type)

template<typename T>
void save_integral(T val, std::false_type)

template<typename T>
void save_integral(T val, std::true_type)

template<class Promoted>
void save_integral_impl(Promoted l)

void save_binary(void const *address, std::size_t count)

void save_binary_chunk(void const *address, std::size_t count)

Protected Attributes

std::unique_ptr<erased_output_container> buffer_

Private Static Functions

static std::uint32_t make_flags(std::uint32_t flags, std::vector<serialization_chunk> *chunks)

Friends

friend hpx::serialization::basic_archive< output_archive >

friend hpx::serialization::array

namespace hpx

namespace serialization

template<typename Container, typename Chunker>
struct filtered_output_container : public hpx::serialization::output_container<Container, Chunker>

Public Types

template<>
using access_traits = traits::serialization_access_data<Container>

template<>
using base_type = output_container<Container, Chunker>

Public Functions

filtered_output_container(Container &cont, std::vector<serialization_chunk> *chunks = nullptr)

~filtered_output_container()

void flush()

void set_filter(binary_filter *filter)

void save_binary(void const *address, std::size_t count)

std::size_t save_binary_chunk(void const *address, std::size_t count)

Protected Attributes

std::size_t start_compressing_at_

binary_filter *filter_

template<typename Container, typename Chunker>
struct output_container : public hpx::serialization::erased_output_container

Subclassed by hpx::serialization::filtered_output_container< Container, Chunker >

Public Types

template<>
using access_traits = traits::serialization_access_data<Container>

Public Functions

output_container(Container &cont, std::vector<serialization_chunk> *chunks = nullptr)

~output_container()

void flush()

std::size_t get_num_chunks() const

void reset()

void set_filter(binary_filter*)

void save_binary(void const *address, std::size_t count)

std::size_t save_binary_chunk(void const *address, std::size_t count)

bool is_preprocessing() const

Protected Attributes

Container &cont_

std::size_t current_

Chunker chunker_

template<typename IArch, typename OArch, typename Char>
class basic_any<IArch, OArch, Char, std::true_type>

Public Functions

constexpr basic_any()

basic_any(basic_any const &x)

basic_any(basic_any &&x)

template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value>::type>
basic_any(T &&x, typename std::enable_if<std::is_copy_constructible<typename std::decay<T>::type>::value>::type* = nullptr)

~basic_any()

basic_any &operator=(basic_any const &x)

basic_any &operator=(basic_any &&rhs)

template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type>
basic_any &operator=(T &&rhs)

basic_any &swap(basic_any &x)

std::type_info const &type() const

template<typename T>
T const &cast() const

bool has_value() const

void reset()

bool equal_to(basic_any const &rhs) const

Private Functions

basic_any &assign(basic_any const &x)

void load(IArch &ar, const unsigned version)

void save(OArch &ar, const unsigned version) const

HPX_SERIALIZATION_SPLIT_MEMBER()

Private Members

detail::any::fxn_ptr_table<IArch, OArch, Char, std::true_type> *table

void *object

Private Static Functions

template<typename T, typename ...Ts>
static void new_object(void *&object, std::true_type, Ts&&... ts)

template<typename T, typename ...Ts>
static void new_object(void *&object, std::false_type, Ts&&... ts)

Friends

friend hpx::serialization::access

namespace hpx

Typedefs

using any = util::basic_any<serialization::input_archive, serialization::output_archive, char, std::true_type>

Functions

template<typename T, typename Char>
util::basic_any<serialization::input_archive, serialization::output_archive, Char> make_any(T &&t)

namespace util

Typedefs

using instead = basic_any<serialization::input_archive, serialization::output_archive, char, std::true_type>

using wany = basic_any<serialization::input_archive, serialization::output_archive, wchar_t, std::true_type>

Functions

template<typename T, typename Char>hpx::util::HPX_DEPRECATED_V(1, 6, "hpx::util::make_any is deprecated. Please use hpx::make_any instead.")

template<typename IArch, typename OArch, typename Char>
class basic_any<IArch, OArch, Char, std::true_type>

Public Functions

constexpr basic_any()

basic_any(basic_any const &x)

basic_any(basic_any &&x)

template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value>::type>
basic_any(T &&x, typename std::enable_if<std::is_copy_constructible<typename std::decay<T>::type>::value>::type* = nullptr)

~basic_any()

basic_any &operator=(basic_any const &x)

basic_any &operator=(basic_any &&rhs)

template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type>
basic_any &operator=(T &&rhs)

basic_any &swap(basic_any &x)

std::type_info const &type() const

template<typename T>
T const &cast() const

bool has_value() const

void reset()

bool equal_to(basic_any const &rhs) const

Private Functions

basic_any &assign(basic_any const &x)

void load(IArch &ar, const unsigned version)

void save(OArch &ar, const unsigned version) const

HPX_SERIALIZATION_SPLIT_MEMBER()

Private Members

detail::any::fxn_ptr_table<IArch, OArch, Char, std::true_type> *table

void *object

Private Static Functions

template<typename T, typename ...Ts>
static void new_object(void *&object, std::true_type, Ts&&... ts)

template<typename T, typename ...Ts>
static void new_object(void *&object, std::false_type, Ts&&... ts)

Friends

friend hpx::util::hpx::serialization::access

struct hash_any

Public Functions

template<typename Char>
std::size_t operator()(const basic_any<serialization::input_archive, serialization::output_archive, Char, std::true_type> &elem) const

namespace hpx

namespace serialization

Enums

enum chunk_type

Values:

chunk_type_index = 0

chunk_type_pointer = 1

Functions

serialization_chunk create_index_chunk(std::size_t index, std::size_t size)

serialization_chunk create_pointer_chunk(void const *pos, std::size_t size, std::uint64_t rkey = 0)

union chunk_data

Public Members

std::size_t index_

void const *cpos_

void *pos_

struct serialization_chunk

Public Members

chunk_data data_

std::size_t size_

std::uint64_t rkey_

std::uint8_t type_

Defines

HPX_SERIALIZATION_SPLIT_MEMBER()

HPX_SERIALIZATION_SPLIT_FREE(T)

HPX_SERIALIZATION_SPLIT_FREE_TEMPLATE(TEMPLATE, ARGS)

namespace hpx

namespace serialization

Functions

template<typename T>
output_archive &operator<<(output_archive &ar, T const &t)

template<typename T>
input_archive &operator>>(input_archive &ar, T &t)

template<typename T>
output_archive &operator&(output_archive &ar, T const &t)

template<typename T>
input_archive &operator&(input_archive &ar, T &t)

namespace hpx

namespace serialization

template<typename T, typename Allocator = std::allocator<T>>
class serialize_buffer

Public Types

enum init_mode

Values:

copy = 0

reference = 1

take = 2

template<>
using value_type = T

Public Functions

serialize_buffer(allocator_type const &alloc = allocator_type())

serialize_buffer(std::size_t size, allocator_type const &alloc = allocator_type())

serialize_buffer(T *data, std::size_t size, init_mode mode = copy, allocator_type const &alloc = allocator_type())

template<typename Deallocator>
serialize_buffer(T *data, std::size_t size, allocator_type const &alloc, Deallocator const &dealloc)

template<typename Deleter>
serialize_buffer(T *data, std::size_t size, init_mode mode, Deleter const &deleter, allocator_type const &alloc = allocator_type())

template<typename Deleter>
serialize_buffer(T const *data, std::size_t size, init_mode mode, Deleter const &deleter, allocator_type const &alloc = allocator_type())

template<typename Deallocator, typename Deleter>
serialize_buffer(T *data, std::size_t size, allocator_type const &alloc, Deallocator const&, Deleter const &deleter)

serialize_buffer(T const *data, std::size_t size, allocator_type const &alloc = allocator_type())

template<typename Deleter>
serialize_buffer(T const *data, std::size_t size, Deleter const &deleter, allocator_type const &alloc = allocator_type())

serialize_buffer(T const *data, std::size_t size, init_mode mode, allocator_type const &alloc = allocator_type())

T *data()

T const *data() const

T *begin()

T *end()

T &operator[](std::size_t idx)

T operator[](std::size_t idx) const

buffer_type data_array() const

std::size_t size() const

void resize_norealloc(std::size_t newsize)

Private Types

template<>
using allocator_type = Allocator

template<>
using buffer_type = boost::shared_array<T>

Private Functions

template<typename Archive>
void save(Archive &ar, unsigned int const) const

template<typename Archive>
void load(Archive &ar, unsigned int const)

Private Members

buffer_type data_

std::size_t size_

Allocator alloc_

Private Static Functions

static void no_deleter(T*)

template<typename Deallocator>
static void deleter(T *p, Deallocator dealloc, std::size_t size)

Friends

friend hpx::serialization::hpx::serialization::access

bool operator==(serialize_buffer const &rhs, serialize_buffer const &lhs)

namespace hpx

namespace serialization

Functions

template<typename T, typename Compare, typename Allocator>
void serialize(input_archive &ar, std::set<T, Compare, Allocator> &set, unsigned)

template<typename T, typename Compare, typename Allocator>
void serialize(output_archive &ar, std::set<T, Compare, Allocator> const &set, unsigned)

namespace hpx

namespace serialization

Functions

template<typename T>
void load(input_archive &ar, std::shared_ptr<T> &ptr, unsigned)

template<typename T>
void save(output_archive &ar, std::shared_ptr<T> const &ptr, unsigned)

namespace hpx

namespace serialization

Functions

template<typename Archive, typename ...Ts>
void serialize(Archive &ar, std::tuple<Ts...> &t, unsigned int version)

template<typename Archive>
void serialize(Archive&, std::tuple<>&, unsigned int)

namespace hpx

namespace serialization

Functions

template<typename Char, typename CharTraits, typename Allocator>
void serialize(input_archive &ar, std::basic_string<Char, CharTraits, Allocator> &s, unsigned)

template<typename Char, typename CharTraits, typename Allocator>
void serialize(output_archive &ar, std::basic_string<Char, CharTraits, Allocator> const &s, unsigned)

namespace hpx

namespace serialization

Functions

template<typename Archive, typename ...Ts>
void serialize(Archive &ar, hpx::tuple<Ts...> &t, unsigned int version)

template<typename Archive>
void serialize(Archive&, hpx::tuple<>&, unsigned)

template<typename Archive, typename ...Ts>
void load_construct_data(Archive &ar, hpx::tuple<Ts...> *t, unsigned int version)

template<typename Archive, typename ...Ts>
void save_construct_data(Archive &ar, hpx::tuple<Ts...> const *t, unsigned int version)

namespace hpx

namespace serialization

Functions

template<typename T>
void load(input_archive &ar, std::unique_ptr<T> &ptr, unsigned)

template<typename T>
void save(output_archive &ar, const std::unique_ptr<T> &ptr, unsigned)

namespace hpx

namespace serialization

Functions

template<typename Key, typename Value, typename Hash, typename KeyEqual, typename Alloc>
void serialize(input_archive &ar, std::unordered_map<Key, Value, Hash, KeyEqual, Alloc> &t, unsigned)

template<typename Key, typename Value, typename Hash, typename KeyEqual, typename Alloc>
void serialize(output_archive &ar, const std::unordered_map<Key, Value, Hash, KeyEqual, Alloc> &t, unsigned)

namespace hpx

namespace serialization

Functions

template<typename T>
void serialize(input_archive &ar, std::valarray<T> &arr, int)

template<typename T>
void serialize(output_archive &ar, std::valarray<T> const &arr, int)

namespace hpx

namespace serialization

Functions

template<typename Allocator>
void serialize(input_archive &ar, std::vector<bool, Allocator> &v, unsigned)

template<typename T, typename Allocator>
void serialize(input_archive &ar, std::vector<T, Allocator> &v, unsigned)

template<typename Allocator>
void serialize(output_archive &ar, std::vector<bool, Allocator> const &v, unsigned)

template<typename T, typename Allocator>
void serialize(output_archive &ar, std::vector<T, Allocator> const &v, unsigned)

Defines

HPX_IS_BITWISE_SERIALIZABLE(T)

namespace hpx

namespace traits

Variables

template<typename T>HPX_INLINE_CONSTEXPR_VARIABLE bool hpx::traits::is_bitwise_serializable_v=is_bitwise_serializable<T>::value

Defines

HPX_IS_NOT_BITWISE_SERIALIZABLE(T)

namespace hpx

namespace traits

Variables

template<typename T>HPX_INLINE_CONSTEXPR_VARIABLE bool hpx::traits::is_not_bitwise_serializable_v=is_not_bitwise_serializable<T>::value

Defines

HPX_TRAITS_NONINTRUSIVE_POLYMORPHIC(Class)

HPX_TRAITS_NONINTRUSIVE_POLYMORPHIC_TEMPLATE(TEMPLATE, ARG_LIST)

HPX_TRAITS_SERIALIZED_WITH_ID(Class)

HPX_TRAITS_SERIALIZED_WITH_ID_TEMPLATE(TEMPLATE, ARG_LIST)

namespace hpx

namespace traits

template<typename Container>
struct default_serialization_access_data

Subclassed by hpx::traits::serialization_access_data< Container >

Public Types

template<>
using preprocessing_only = std::false_type

Public Static Functions

static constexpr bool is_preprocessing()

static constexpr void write(Container&, std::size_t, std::size_t, void const*)

static bool flush(serialization::binary_filter*, Container&, std::size_t, std::size_t size, std::size_t &written)

static constexpr void read(Container const&, std::size_t, std::size_t, void*)

static constexpr std::size_t init_data(Container const&, serialization::binary_filter*, std::size_t, std::size_t decompressed_size)

static constexpr void reset(Container&)

template<typename Container>
struct serialization_access_data : public hpx::traits::default_serialization_access_data<Container>

Subclassed by hpx::traits::serialization_access_data< Container const >

Public Static Functions

static std::size_t size(Container const &cont)

static void resize(Container &cont, std::size_t count)

static void write(Container &cont, std::size_t count, std::size_t current, void const *address)

static bool flush(serialization::binary_filter *filter, Container &cont, std::size_t current, std::size_t size, std::size_t &written)

static void read(Container const &cont, std::size_t count, std::size_t current, void *address)

static std::size_t init_data(Container const &cont, serialization::binary_filter *filter, std::size_t current, std::size_t decompressed_size)