serialization¶

`#include <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¶

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

`#include <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)¶

`#include <hpx/serialization/input_archive.hpp>`¶

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

`#include <hpx/serialization/base_object.hpp>`¶

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_

`#include <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)¶

`#include <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¶

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

`#include <hpx/serialization/access.hpp>`¶

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

`#include <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)¶

`#include <hpx/serialization/container.hpp>`¶

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¶

`#include <hpx/serialization/intrusive_ptr.hpp>`¶

`#include <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)¶

`#include <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)¶

`#include <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)¶

`#include <hpx/serialization/binary_filter.hpp>`¶

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

`#include <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>¶

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

`#include <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¶

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¶

`#include <hpx/serialization/output_archive.hpp>`¶

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

`#include <hpx/serialization/serialize_buffer.hpp>`¶

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

boost::shared_array<T> data_array() const¶

std::size_t size() const¶

Private Types

template<> using allocator_type = Allocator¶

Private Functions

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

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

Private Members

boost::shared_array<T> 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)¶

`#include <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)¶

`#include <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)¶

`#include <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)¶

`#include <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 >))

`#include <hpx/serialization/multi_array.hpp>`¶

`#include <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)¶

`#include <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)¶

`#include <hpx/serialization/brace_initializable_fwd.hpp>`¶

`#include <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)¶

`#include <hpx/serialization/brace_initializable.hpp>`¶

`#include <hpx/serialization/variant.hpp>`¶

`#include <hpx/serialization/dynamic_bitset.hpp>`¶

`#include <hpx/serialization/input_container.hpp>`¶

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¶

`#include <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)

`#include <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)¶

`#include <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)¶

`#include <hpx/serialization/traits/serialization_access_data.hpp>`¶

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 bool is_preprocessing()¶

static HPX_CXX14_CONSTEXPR void hpx::traits::default_serialization_access_data::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 HPX_CXX14_CONSTEXPR void hpx::traits::default_serialization_access_data::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)¶

static HPX_CXX14_CONSTEXPR void hpx::traits::default_serialization_access_data::reset(Container & cont)

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

`#include <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)¶

`#include <hpx/serialization/traits/is_bitwise_serializable.hpp>`¶

Defines

HPX_IS_BITWISE_SERIALIZABLE(T)¶

serialization¶

#include <hpx/serialization/serialization_chunk.hpp>¶

#include <hpx/serialization/bitset.hpp>¶

#include <hpx/serialization/input_archive.hpp>¶

#include <hpx/serialization/base_object.hpp>¶

#include <hpx/serialization/serialization_fwd.hpp>¶

#include <hpx/serialization/basic_archive.hpp>¶

#include <hpx/serialization/access.hpp>¶

#include <hpx/serialization/complex.hpp>¶

#include <hpx/serialization/container.hpp>¶

#include <hpx/serialization/intrusive_ptr.hpp>¶

#include <hpx/serialization/vector.hpp>¶

#include <hpx/serialization/valarray.hpp>¶

#include <hpx/serialization/tuple.hpp>¶

#include <hpx/serialization/binary_filter.hpp>¶

#include <hpx/serialization/output_container.hpp>¶

#include <hpx/serialization/array.hpp>¶

#include <hpx/serialization/output_archive.hpp>¶

#include <hpx/serialization/serialize_buffer.hpp>¶

#include <hpx/serialization/map.hpp>¶

#include <hpx/serialization/list.hpp>¶

#include <hpx/serialization/unique_ptr.hpp>¶

#include <hpx/serialization/optional.hpp>¶

#include <hpx/serialization/multi_array.hpp>¶

#include <hpx/serialization/deque.hpp>¶

#include <hpx/serialization/unordered_map.hpp>¶

#include <hpx/serialization/brace_initializable_fwd.hpp>¶

#include <hpx/serialization/string.hpp>¶

#include <hpx/serialization/brace_initializable.hpp>¶

#include <hpx/serialization/variant.hpp>¶

#include <hpx/serialization/dynamic_bitset.hpp>¶

#include <hpx/serialization/input_container.hpp>¶

#include <hpx/serialization/serialize.hpp>¶

#include <hpx/serialization/shared_ptr.hpp>¶

#include <hpx/serialization/set.hpp>¶

#include <hpx/serialization/traits/serialization_access_data.hpp>¶

#include <hpx/serialization/traits/polymorphic_traits.hpp>¶

#include <hpx/serialization/traits/is_bitwise_serializable.hpp>¶

#include <hpx/serialization/traits/brace_initializable_traits.hpp>¶

#include <hpx/serialization/traits/needs_automatic_registration.hpp>¶

#include <compatibility/hpx/runtime/serialization/serialization_chunk.hpp>¶

#include <compatibility/hpx/runtime/serialization/bitset.hpp>¶

#include <compatibility/hpx/runtime/serialization/input_archive.hpp>¶

#include <compatibility/hpx/runtime/serialization/base_object.hpp>¶

#include <compatibility/hpx/runtime/serialization/serialization_fwd.hpp>¶

#include <compatibility/hpx/runtime/serialization/basic_archive.hpp>¶

#include <compatibility/hpx/runtime/serialization/access.hpp>¶

#include <compatibility/hpx/runtime/serialization/complex.hpp>¶

#include <compatibility/hpx/runtime/serialization/container.hpp>¶

#include <compatibility/hpx/runtime/serialization/intrusive_ptr.hpp>¶

#include <compatibility/hpx/runtime/serialization/vector.hpp>¶

#include <compatibility/hpx/runtime/serialization/valarray.hpp>¶

#include <compatibility/hpx/runtime/serialization/tuple.hpp>¶

#include <compatibility/hpx/runtime/serialization/binary_filter.hpp>¶

#include <compatibility/hpx/runtime/serialization/output_container.hpp>¶

#include <compatibility/hpx/runtime/serialization/array.hpp>¶

#include <compatibility/hpx/runtime/serialization/output_archive.hpp>¶

#include <compatibility/hpx/runtime/serialization/serialize_buffer.hpp>¶

#include <compatibility/hpx/runtime/serialization/map.hpp>¶

#include <compatibility/hpx/runtime/serialization/list.hpp>¶

#include <compatibility/hpx/runtime/serialization/unique_ptr.hpp>¶

#include <compatibility/hpx/runtime/serialization/optional.hpp>¶

#include <compatibility/hpx/runtime/serialization/multi_array.hpp>¶

#include <compatibility/hpx/runtime/serialization/deque.hpp>¶

#include <compatibility/hpx/runtime/serialization/unordered_map.hpp>¶

#include <compatibility/hpx/runtime/serialization/brace_initializable_fwd.hpp>¶

#include <compatibility/hpx/runtime/serialization/string.hpp>¶

#include <compatibility/hpx/runtime/serialization/brace_initializable.hpp>¶

#include <compatibility/hpx/runtime/serialization/variant.hpp>¶

#include <compatibility/hpx/runtime/serialization/dynamic_bitset.hpp>¶

#include <compatibility/hpx/runtime/serialization/input_container.hpp>¶

#include <compatibility/hpx/runtime/serialization/serialize.hpp>¶

#include <compatibility/hpx/runtime/serialization/shared_ptr.hpp>¶

#include <compatibility/hpx/runtime/serialization/set.hpp>¶

#include <compatibility/hpx/traits/serialization_access_data.hpp>¶

#include <compatibility/hpx/traits/polymorphic_traits.hpp>¶

#include <compatibility/hpx/traits/is_bitwise_serializable.hpp>¶

#include <compatibility/hpx/traits/brace_initializable_traits.hpp>¶

#include <compatibility/hpx/traits/needs_automatic_registration.hpp>¶

`#include <hpx/serialization/serialization_chunk.hpp>`¶

`#include <hpx/serialization/bitset.hpp>`¶

`#include <hpx/serialization/input_archive.hpp>`¶

`#include <hpx/serialization/base_object.hpp>`¶

`#include <hpx/serialization/serialization_fwd.hpp>`¶

`#include <hpx/serialization/basic_archive.hpp>`¶

`#include <hpx/serialization/access.hpp>`¶

`#include <hpx/serialization/complex.hpp>`¶

`#include <hpx/serialization/container.hpp>`¶

`#include <hpx/serialization/intrusive_ptr.hpp>`¶

`#include <hpx/serialization/vector.hpp>`¶

`#include <hpx/serialization/valarray.hpp>`¶

`#include <hpx/serialization/tuple.hpp>`¶

`#include <hpx/serialization/binary_filter.hpp>`¶

`#include <hpx/serialization/output_container.hpp>`¶

`#include <hpx/serialization/array.hpp>`¶

`#include <hpx/serialization/output_archive.hpp>`¶

`#include <hpx/serialization/serialize_buffer.hpp>`¶

`#include <hpx/serialization/map.hpp>`¶

`#include <hpx/serialization/list.hpp>`¶

`#include <hpx/serialization/unique_ptr.hpp>`¶

`#include <hpx/serialization/optional.hpp>`¶

`#include <hpx/serialization/multi_array.hpp>`¶

`#include <hpx/serialization/deque.hpp>`¶

`#include <hpx/serialization/unordered_map.hpp>`¶

`#include <hpx/serialization/brace_initializable_fwd.hpp>`¶

`#include <hpx/serialization/string.hpp>`¶

`#include <hpx/serialization/brace_initializable.hpp>`¶

`#include <hpx/serialization/variant.hpp>`¶

`#include <hpx/serialization/dynamic_bitset.hpp>`¶

`#include <hpx/serialization/input_container.hpp>`¶

`#include <hpx/serialization/serialize.hpp>`¶

`#include <hpx/serialization/shared_ptr.hpp>`¶

`#include <hpx/serialization/set.hpp>`¶

`#include <hpx/serialization/traits/serialization_access_data.hpp>`¶

`#include <hpx/serialization/traits/polymorphic_traits.hpp>`¶

`#include <hpx/serialization/traits/is_bitwise_serializable.hpp>`¶

`#include <hpx/serialization/traits/brace_initializable_traits.hpp>`¶

`#include <hpx/serialization/traits/needs_automatic_registration.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/serialization_chunk.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/bitset.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/input_archive.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/base_object.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/serialization_fwd.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/basic_archive.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/access.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/complex.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/container.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/intrusive_ptr.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/vector.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/valarray.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/tuple.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/binary_filter.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/output_container.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/array.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/output_archive.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/serialize_buffer.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/map.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/list.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/unique_ptr.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/optional.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/multi_array.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/deque.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/unordered_map.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/brace_initializable_fwd.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/string.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/brace_initializable.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/variant.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/dynamic_bitset.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/input_container.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/serialize.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/shared_ptr.hpp>`¶

`#include <compatibility/hpx/runtime/serialization/set.hpp>`¶

`#include <compatibility/hpx/traits/serialization_access_data.hpp>`¶

`#include <compatibility/hpx/traits/polymorphic_traits.hpp>`¶

`#include <compatibility/hpx/traits/is_bitwise_serializable.hpp>`¶

`#include <compatibility/hpx/traits/brace_initializable_traits.hpp>`¶

`#include <compatibility/hpx/traits/needs_automatic_registration.hpp>`¶