serialization

#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/brace_initializable_fwd.hpp>

#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/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/intrusive_ptr.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/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/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/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/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/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/dynamic_bitset.hpp>

#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/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/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/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/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/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/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/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/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/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/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/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/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/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/brace_initializable.hpp>

#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/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/variant.hpp>

#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/multi_array.hpp>

#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/traits/brace_initializable_traits.hpp>

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

Defines

HPX_IS_BITWISE_SERIALIZABLE(T)

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

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/needs_automatic_registration.hpp>

#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 <compatibility/hpx/traits/brace_initializable_traits.hpp>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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