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.

Header hpx/serialization.hpp

Header hpx/serialization/access.hpp

template<typename T>
struct serialize_non_intrusive<T, typename std::enable_if<has_serialize_adl<T>::value>::type>
#include <access.hpp>

Public Static Functions

template<typename Archive>
static void call(Archive &ar, T &t, unsigned)
namespace hpx
namespace serialization
class access
#include <access.hpp>

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
#include <access.hpp>

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>
#include <access.hpp>

Public Static Functions

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

Header hpx/serialization/array.hpp

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
#include <array.hpp>

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

Header hpx/serialization/base_object.hpp

template<typename Derived, typename Base>
struct base_object_type<Derived, Base, std::true_type>
#include <base_object.hpp>

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
#include <base_object.hpp>

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>
#include <base_object.hpp>

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_

Header hpx/serialization/basic_archive.hpp

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
#include <basic_archive.hpp>

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_

Header hpx/serialization/binary_filter.hpp

namespace hpx
namespace serialization
struct binary_filter
#include <binary_filter.hpp>

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()

Header hpx/serialization/bitset.hpp

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)

Header hpx/serialization/boost_variant.hpp

Header hpx/serialization/brace_initializable.hpp

Header hpx/serialization/brace_initializable_fwd.hpp

Header hpx/serialization/complex.hpp

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)

Header hpx/serialization/container.hpp

namespace hpx
namespace serialization
struct erased_input_container
#include <container.hpp>

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
#include <container.hpp>

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

Header hpx/serialization/datapar.hpp

Header hpx/serialization/deque.hpp

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)

Header hpx/serialization/dynamic_bitset.hpp

Header hpx/serialization/exception_ptr.hpp

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

Header hpx/serialization/input_archive.hpp

namespace hpx
namespace serialization
struct input_archive : public hpx::serialization::basic_archive<input_archive>
#include <input_archive.hpp>

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

Header hpx/serialization/input_container.hpp

namespace hpx
namespace serialization
template<typename Container>
struct input_container : public hpx::serialization::erased_input_container
#include <input_container.hpp>

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

Header hpx/serialization/intrusive_ptr.hpp

Header hpx/serialization/list.hpp

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)

Header hpx/serialization/map.hpp

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)

Header hpx/serialization/multi_array.hpp

Header hpx/serialization/optional.hpp

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 >))

Header hpx/serialization/output_archive.hpp

namespace hpx
namespace serialization
struct output_archive : public hpx::serialization::basic_archive<output_archive>
#include <output_archive.hpp>

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

Header hpx/serialization/output_container.hpp

namespace hpx
namespace serialization
template<typename Container, typename Chunker>
struct filtered_output_container : public hpx::serialization::output_container<Container, Chunker>
#include <output_container.hpp>

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
#include <output_container.hpp>

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 *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_

Header hpx/serialization/serializable_any.hpp

template<typename IArch, typename OArch, typename Char>
class basic_any<IArch, OArch, Char, std::true_type>
#include <serializable_any.hpp>

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
namespace util

Typedefs

using any = 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>
basic_any<serialization::input_archive, serialization::output_archive, Char> make_any(T &&t)
template<typename IArch, typename OArch, typename Char>
class basic_any<IArch, OArch, Char, std::true_type>
#include <serializable_any.hpp>

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
#include <serializable_any.hpp>

Public Functions

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

Header hpx/serialization/serialization_chunk.hpp

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
#include <serialization_chunk.hpp>

Public Members

std::size_t index_
void const *cpos_
void *pos_
struct serialization_chunk
#include <serialization_chunk.hpp>

Public Members

chunk_data data_
std::size_t size_
std::uint64_t rkey_
std::uint8_t type_

Header hpx/serialization/serialization_fwd.hpp

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)

Header hpx/serialization/serialize.hpp

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)

Header hpx/serialization/serialize_buffer.hpp

namespace hpx
namespace serialization
template<typename T, typename Allocator = std::allocator<T>>
class serialize_buffer
#include <serialize_buffer.hpp>

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 &dealloc, 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

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)

Header hpx/serialization/set.hpp

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)

Header hpx/serialization/shared_ptr.hpp

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)

Header hpx/serialization/std_tuple.hpp

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 &ar, std::tuple<>&, unsigned int)

Header hpx/serialization/string.hpp

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)

Header hpx/serialization/traits/brace_initializable_traits.hpp

Header hpx/serialization/traits/is_bitwise_serializable.hpp

Defines

HPX_IS_BITWISE_SERIALIZABLE(T)

Header hpx/serialization/traits/needs_automatic_registration.hpp

Header hpx/serialization/traits/polymorphic_traits.hpp

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)

Header hpx/serialization/traits/serialization_access_data.hpp

namespace hpx
namespace traits
template<typename Container>
struct default_serialization_access_data
#include <serialization_access_data.hpp>

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 &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 constexpr void read(Container const &cont, std::size_t count, std::size_t current, void *address)
static constexpr std::size_t init_data(Container const &cont, serialization::binary_filter *filter, std::size_t current, std::size_t decompressed_size)
static constexpr void reset(Container &cont)
template<typename Container>
struct serialization_access_data : public hpx::traits::default_serialization_access_data<Container>
#include <serialization_access_data.hpp>

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)

Header hpx/serialization/tuple.hpp

namespace hpx
namespace serialization

Functions

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

Header hpx/serialization/unique_ptr.hpp

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)

Header hpx/serialization/unordered_map.hpp

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)

Header hpx/serialization/valarray.hpp

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)

Header hpx/serialization/variant.hpp

Header hpx/serialization/vector.hpp

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)