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

serialization¶

Header hpx/serialization.hpp¶

Header hpx/serialization/access.hpp¶

Header hpx/serialization/array.hpp¶

Header hpx/serialization/base_object.hpp¶

Header hpx/serialization/basic_archive.hpp¶

Header hpx/serialization/binary_filter.hpp¶

Header hpx/serialization/bitset.hpp¶

Header hpx/serialization/boost_variant.hpp¶

Header hpx/serialization/brace_initializable.hpp¶

Header hpx/serialization/brace_initializable_fwd.hpp¶

Header hpx/serialization/complex.hpp¶

Header hpx/serialization/container.hpp¶

Header hpx/serialization/datapar.hpp¶

Header hpx/serialization/deque.hpp¶

Header hpx/serialization/dynamic_bitset.hpp¶

Header hpx/serialization/exception_ptr.hpp¶

Header hpx/serialization/input_archive.hpp¶

Header hpx/serialization/input_container.hpp¶

Header hpx/serialization/intrusive_ptr.hpp¶

Header hpx/serialization/list.hpp¶

Header hpx/serialization/map.hpp¶

Header hpx/serialization/multi_array.hpp¶

Header hpx/serialization/optional.hpp¶

Header hpx/serialization/output_archive.hpp¶

Header hpx/serialization/output_container.hpp¶

Header hpx/serialization/serializable_any.hpp¶

Header hpx/serialization/serialization_chunk.hpp¶

Header hpx/serialization/serialization_fwd.hpp¶

Header hpx/serialization/serialize.hpp¶

Header hpx/serialization/serialize_buffer.hpp¶

Header hpx/serialization/set.hpp¶

Header hpx/serialization/shared_ptr.hpp¶

Header hpx/serialization/std_tuple.hpp¶

Header hpx/serialization/string.hpp¶

Header hpx/serialization/traits/brace_initializable_traits.hpp¶

Header hpx/serialization/traits/is_bitwise_serializable.hpp¶

Header hpx/serialization/traits/needs_automatic_registration.hpp¶

Header hpx/serialization/traits/polymorphic_traits.hpp¶

Header hpx/serialization/traits/serialization_access_data.hpp¶

Header hpx/serialization/tuple.hpp¶

Header hpx/serialization/unique_ptr.hpp¶

Header hpx/serialization/unordered_map.hpp¶

Header hpx/serialization/valarray.hpp¶

Header hpx/serialization/variant.hpp¶

Header hpx/serialization/vector.hpp¶

Header `hpx/serialization.hpp`¶

Header `hpx/serialization/access.hpp`¶

Header `hpx/serialization/array.hpp`¶

Header `hpx/serialization/base_object.hpp`¶

Header `hpx/serialization/basic_archive.hpp`¶

Header `hpx/serialization/binary_filter.hpp`¶

Header `hpx/serialization/bitset.hpp`¶

Header `hpx/serialization/boost_variant.hpp`¶

Header `hpx/serialization/brace_initializable.hpp`¶

Header `hpx/serialization/brace_initializable_fwd.hpp`¶

Header `hpx/serialization/complex.hpp`¶

Header `hpx/serialization/container.hpp`¶

Header `hpx/serialization/datapar.hpp`¶

Header `hpx/serialization/deque.hpp`¶

Header `hpx/serialization/dynamic_bitset.hpp`¶

Header `hpx/serialization/exception_ptr.hpp`¶

Header `hpx/serialization/input_archive.hpp`¶

Header `hpx/serialization/input_container.hpp`¶

Header `hpx/serialization/intrusive_ptr.hpp`¶

Header `hpx/serialization/list.hpp`¶

Header `hpx/serialization/map.hpp`¶

Header `hpx/serialization/multi_array.hpp`¶

Header `hpx/serialization/optional.hpp`¶

Header `hpx/serialization/output_archive.hpp`¶

Header `hpx/serialization/output_container.hpp`¶

Header `hpx/serialization/serializable_any.hpp`¶

Header `hpx/serialization/serialization_chunk.hpp`¶

Header `hpx/serialization/serialization_fwd.hpp`¶

Header `hpx/serialization/serialize.hpp`¶

Header `hpx/serialization/serialize_buffer.hpp`¶

Header `hpx/serialization/set.hpp`¶

Header `hpx/serialization/shared_ptr.hpp`¶

Header `hpx/serialization/std_tuple.hpp`¶

Header `hpx/serialization/string.hpp`¶

Header `hpx/serialization/traits/brace_initializable_traits.hpp`¶

Header `hpx/serialization/traits/is_bitwise_serializable.hpp`¶

Header `hpx/serialization/traits/needs_automatic_registration.hpp`¶

Header `hpx/serialization/traits/polymorphic_traits.hpp`¶

Header `hpx/serialization/traits/serialization_access_data.hpp`¶

Header `hpx/serialization/tuple.hpp`¶

Header `hpx/serialization/unique_ptr.hpp`¶

Header `hpx/serialization/unordered_map.hpp`¶

Header `hpx/serialization/valarray.hpp`¶

Header `hpx/serialization/variant.hpp`¶

Header `hpx/serialization/vector.hpp`¶