serialization C++ API Reference

template<class Archive, class Serializable>
struct _ptr_serialization_support : public icecube::archive::detail::ptr_serialization_support<Archive, Serializable>

#include <register_archive.hpp>

Public Types

typedef int type

struct abstract

#include <iserializer.hpp>

Public Static Functions

template<class T>
static inline const basic_pointer_iserializer *register_type(Archive&)

struct abstract

#include <oserializer.hpp>

Public Static Functions

template<class T>
static inline const basic_pointer_oserializer *register_type(Archive&)

class access

#include <access.hpp>

Public Static Functions

template<class Archive, class T>
static inline void member_save(Archive &ar, T &t, const unsigned int file_version)

template<class Archive, class T>
static inline void member_load(Archive &ar, T &t, const unsigned int file_version)

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

template<class T>
static inline void destroy(const T *t)

template<class T>
static inline void construct(T *t)

template<class T, class U>
static inline T &cast_reference(U &u)

template<class T, class U>
static inline T *cast_pointer(U *u)

Friends

friend struct detail::member_saver

friend struct detail::member_loader

friend class archive::detail::iserializer

friend class archive::detail::oserializer

template<class Archive, class T> inline friend void serialize (Archive &ar, T &t, const I3_PFTO unsigned int file_version)

template<class Archive, class T> inline friend void save_construct_data (Archive &ar, const T *t, const I3_PFTO unsigned int file_version)

template<class Archive, class T> inline friend void load_construct_data (Archive &ar, T *t, const I3_PFTO unsigned int file_version)

template<bool tf>
struct action

Public Static Functions

static inline const char *invoke()

struct adl_tag

#include <register_archive.hpp>

struct aobject

Public Functions

inline aobject(void *a, class_id_type class_id_)

inline aobject()

Public Members

void *address

bool loaded_as_pointer

class_id_type class_id

struct aobject

Public Functions

inline bool operator<(const aobject &rhs) const

inline aobject &operator=(const aobject &rhs)

inline aobject(const void *a, class_id_type class_id_, object_id_type object_id_)

inline aobject()

Public Members

const void *address

class_id_type class_id

object_id_type object_id

template<class T>
struct apply : public icecube::serialization::is_bitwise_serializable<T>

#include <portable_binary_archive.hpp>

template<class T>
struct apply : public icecube::serialization::is_bitwise_serializable<T>

#include <portable_binary_archive.hpp>

template<class T>
struct apply : public icecube::serialization::is_bitwise_serializable<T>

#include <basic_binary_iprimitive.hpp>

template<class T>
struct apply : public icecube::serialization::is_bitwise_serializable<T>

#include <basic_binary_oprimitive.hpp>

template<class Archive, class Container>
struct archive_input_map

#include <collections_load_imp.hpp>

Public Functions

inline void operator()(Archive &ar, Container &s, const unsigned int v)

template<class Archive, class Container>
struct archive_input_multimap

#include <collections_load_imp.hpp>

Public Functions

inline void operator()(Archive &ar, Container &s, const unsigned int v)

template<class Archive, class Container>
struct archive_input_multiset

#include <collections_load_imp.hpp>

Public Functions

inline void operator()(Archive &ar, Container &s, const unsigned int v)

template<class Archive, class Container>
struct archive_input_seq

#include <collections_load_imp.hpp>

Public Functions

inline void operator()(Archive &ar, Container &s, const unsigned int v)

template<class Archive, class Container>
struct archive_input_set

#include <collections_load_imp.hpp>

Public Functions

inline void operator()(Archive &ar, Container &s, const unsigned int v)

template<class Archive, class Container>
struct archive_input_unordered_map

#include <unordered_map.hpp>

Public Functions

inline void operator()(Archive &ar, Container &s, const unsigned int v)

template<class Archive, class Container>
struct archive_input_unordered_multimap

#include <unordered_map.hpp>

Public Functions

inline void operator()(Archive &ar, Container &s, const unsigned int v)

template<class Archive, class Container>
struct archive_input_unordered_multiset

#include <unordered_set.hpp>

Public Functions

inline void operator()(Archive &ar, Container &s, const unsigned int v)

template<class Archive, class Container>
struct archive_input_unordered_set

#include <unordered_set.hpp>

Public Functions

inline void operator()(Archive &ar, Container &s, const unsigned int v)

template<class T>
class array : public icecube::serialization::wrapper_traits<const array<T>>

#include <array.hpp>

Public Types

typedef T value_type

Public Functions

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

inline array(const array &rhs)

inline array &operator=(const array &rhs)

template<class Archive>
inline void serialize_optimized(Archive &ar, const unsigned int, boost::mpl::false_) const

template<class Archive>
inline void serialize_optimized(Archive &ar, const unsigned int version, boost::mpl::true_)

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

template<class Archive>
inline void load(Archive &ar, const unsigned int version)

template<class Archive>
inline void serialize(Archive &ar, const unsigned int version)

inline value_type *address() const

inline std::size_t count() const

Private Members

value_type *m_t

std::size_t m_element_count

template<>
class back_insert_iterator<basic_string<char>> : public iterator<output_iterator_tag, char>

#include <dinkumware.hpp>

Public Types

typedef basic_string<char> container_type

typedef container_type::reference reference

Public Functions

inline explicit back_insert_iterator(container_type &s)

inline back_insert_iterator<container_type> &operator=(container_type::const_reference Val_)

inline back_insert_iterator<container_type> &operator*()

inline back_insert_iterator<container_type> &operator++()

inline back_insert_iterator<container_type> operator++(int)

Protected Attributes

container_type *container

template<>
class back_insert_iterator<basic_string<wchar_t>> : public iterator<output_iterator_tag, wchar_t>

#include <dinkumware.hpp>

Public Types

typedef basic_string<wchar_t> container_type

typedef container_type::reference reference

Public Functions

inline explicit back_insert_iterator(container_type &s)

inline back_insert_iterator<container_type> &operator=(container_type::const_reference Val_)

inline back_insert_iterator<container_type> &operator*()

inline back_insert_iterator<container_type> &operator++()

inline back_insert_iterator<container_type> operator++(int)

Protected Attributes

container_type *container

class bad_weak_ptr : public std::exception

#include <shared_count_132.hpp>

Public Functions

inline virtual char const *what() const noexcept

class base64_exception : public std::exception

#include <base64_exception.hpp>

Public Types

enum exception_code

Values:

enumerator invalid_code

enumerator invalid_character

enumerator other_exception

Public Functions

inline base64_exception(exception_code c = other_exception)

inline virtual const char *what() const

Public Members

exception_code code

template<class Base, class CharType = typename boost::iterator_value<Base>::type>
class base64_from_binary : public boost::transform_iterator<detail::from_6_bit<CharType>, Base>

#include <base64_from_binary.hpp>

Public Functions

template<class T> inline  base64_from_binary (I3_PFTO_WRAPPER(T) start)

inline base64_from_binary(const base64_from_binary &rhs)

Private Types

typedef boost::transform_iterator<typename detail::from_6_bit<CharType>, Base> super_t

template<class B, class D>
struct base_cast

#include <base_object.hpp>

Public Types

typedef boost::mpl::if_<boost::is_const<D>, const B, B>::type type

template<class Base, class Derived>
struct base_register

#include <base_object.hpp>

Public Static Functions

static inline void const *invoke()

template<class Archive>
class basic_binary_iarchive : public icecube::archive::detail::common_iarchive<Archive>

#include <basic_binary_iarchive.hpp>

Subclassed by icecube::archive::binary_iarchive_impl< Archive, Elem, Tr >

Protected Types

typedef detail::common_iarchive<Archive> detail_common_iarchive

Protected Functions

template<class T> inline void load_override (T &t, I3_PFTO int version)

inline void load_override(class_id_optional_type&, int)

inline void load_override(tracking_type &t, int)

inline void load_override(class_id_type &t, int version)

inline void load_override(class_id_reference_type &t, int version)

inline void load_override(version_type &t, int version)

inline void load_override(icecube::serialization::item_version_type &t, int version)

inline void load_override(serialization::collection_size_type &t, int version)

load_override(class_name_type &t, int)

init()

inline basic_binary_iarchive(unsigned int flags)

Friends

friend class detail::interface_iarchive< Archive >

template<class Archive, class Elem, class Tr>
class basic_binary_iprimitive

#include <basic_binary_iprimitive.hpp>

Subclassed by icecube::archive::binary_iarchive_impl< Archive, Elem, Tr >

Public Functions

template<class ValueType>
inline void load_array(serialization::array<ValueType> &a, unsigned int)

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

Protected Functions

inline Archive *This()

template<class T>
inline void load(T &t)

inline void load(bool &t)

load(std::string &s)

load(std::wstring &ws)

load(char *t)

load(wchar_t *t)

init()

basic_binary_iprimitive(std::basic_streambuf<Elem, Tr> &sb, bool no_codecvt)

~basic_binary_iprimitive()

Protected Attributes

std::basic_streambuf<Elem, Tr> &m_sb

boost::scoped_ptr<std::locale> archive_locale

basic_streambuf_locale_saver<Elem, Tr> locale_saver

Friends

friend class load_access

template<class Archive>
class basic_binary_oarchive : public icecube::archive::detail::common_oarchive<Archive>

#include <basic_binary_oarchive.hpp>

Subclassed by icecube::archive::binary_oarchive_impl< Archive, Elem, Tr >

Protected Types

typedef detail::common_oarchive<Archive> detail_common_oarchive

Protected Functions

template<class T> inline void save_override (const T &t, I3_PFTO int version)

inline void save_override(const class_id_optional_type&, int)

inline void save_override(const class_name_type &t, int)

init()

inline basic_binary_oarchive(unsigned int flags)

Friends

friend class detail::interface_oarchive< Archive >

template<class Archive, class Elem, class Tr>
class basic_binary_oprimitive

#include <basic_binary_oprimitive.hpp>

Subclassed by icecube::archive::binary_oarchive_impl< Archive, Elem, Tr >

Public Functions

template<class ValueType>
inline void save_array(icecube::serialization::array<ValueType> const &a, unsigned int)

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

Protected Functions

inline Archive *This()

template<class T>
inline void save(const T &t)

inline void save(const bool t)

save(const std::string &s)

save(const std::wstring &ws)

save(const char *t)

save(const wchar_t *t)

init()

basic_binary_oprimitive(std::basic_streambuf<Elem, Tr> &sb, bool no_codecvt)

~basic_binary_oprimitive()

Protected Attributes

std::basic_streambuf<Elem, Tr> &m_sb

boost::scoped_ptr<std::locale> archive_locale

basic_streambuf_locale_saver<Elem, Tr> locale_saver

Friends

friend class save_access

class basic_iarchive_impl

Private Types

typedef std::vector<aobject> object_id_vector_type

typedef std::set<cobject_type> cobject_info_set_type

typedef std::vector<cobject_id> cobject_id_vector_type

Private Functions

inline void reset_object_address(const void *new_address, const void *old_address)

inline basic_iarchive_impl(unsigned int flags)

inline ~basic_iarchive_impl()

inline void set_library_version(library_version_type archive_library_version)

bool track(basic_iarchive &ar, void *&t)

void load_preamble(basic_iarchive &ar, cobject_id &co)

inline class_id_type register_type(const basic_iserializer &bis)

template<class T>
inline void load(basic_iarchive &ar, T &t)

inline void next_object_pointer(void *t)

inline void delete_created_pointers()

class_id_type register_type(const basic_pointer_iserializer &bpis)

inline void load_object(basic_iarchive &ar, void *t, const basic_iserializer &bis)

inline const basic_pointer_iserializer *load_pointer(basic_iarchive &ar, void *&t, const basic_pointer_iserializer *bpis, const basic_pointer_iserializer *(*finder)(const icecube::serialization::extended_type_info &type))

Private Members

library_version_type m_archive_library_version

unsigned int m_flags

object_id_vector_type object_id_vector

struct icecube::archive::detail::basic_iarchive_impl::moveable_objects m_moveable_objects

cobject_info_set_type cobject_info_set

cobject_id_vector_type cobject_id_vector

struct icecube::archive::detail::basic_iarchive_impl::pending m_pending

Friends

friend class basic_iarchive

class basic_oarchive_impl

Private Types

typedef std::set<aobject> object_set_type

typedef std::set<cobject_type> cobject_info_set_type

Private Functions

inline basic_oarchive_impl(unsigned int flags)

inline const cobject_type &find(const basic_oserializer &bos)

inline const basic_oserializer *find(const serialization::extended_type_info &ti) const

inline const cobject_type &register_type(const basic_oserializer &bos)

inline void save_object(basic_oarchive &ar, const void *t, const basic_oserializer &bos)

inline void save_pointer(basic_oarchive &ar, const void *t, const basic_pointer_oserializer *bpos)

Private Members

unsigned int m_flags

object_set_type object_set

cobject_info_set_type cobject_info_set

std::set<object_id_type> stored_pointers

const void *pending_object

const basic_oserializer *pending_bos

Friends

friend class basic_oarchive

class basic_serializer : private noncopyable

#include <basic_serializer.hpp>

Subclassed by icecube::archive::detail::basic_serializer_arg

Public Functions

inline bool operator<(const basic_serializer &rhs) const

inline const char *get_debug_info() const

inline const icecube::serialization::extended_type_info &get_eti() const

Protected Functions

inline explicit basic_serializer(const icecube::serialization::extended_type_info &eti)

Private Members

const icecube::serialization::extended_type_info *m_eti

class basic_serializer_arg : public icecube::archive::detail::basic_serializer

#include <basic_serializer.hpp>

Public Functions

inline basic_serializer_arg(const serialization::extended_type_info &eti)

template<typename Ch, class Tr>
class basic_streambuf_locale_saver : private noncopyable

#include <basic_streambuf_locale_saver.hpp>

Public Types

typedef ::std::basic_streambuf<Ch, Tr> state_type

typedef ::std::locale aspect_type

Public Functions

inline explicit basic_streambuf_locale_saver(state_type &s)

inline explicit basic_streambuf_locale_saver(state_type &s, aspect_type const &a)

inline ~basic_streambuf_locale_saver()

inline void restore()

Private Members

state_type &s_save_

aspect_type const a_save_

template<class Archive>
class basic_text_iarchive : public icecube::archive::detail::common_iarchive<Archive>

#include <basic_text_iarchive.hpp>

Subclassed by icecube::archive::text_iarchive_impl< Archive >, icecube::archive::text_wiarchive_impl< Archive >

Protected Types

typedef detail::common_iarchive<Archive> detail_common_iarchive

Protected Functions

template<class T>
inline void load_override(T &t, I3_PFTO int)

inline void load_override(class_id_optional_type&, int)

load_override(class_name_type &t, int)

init(void)

inline basic_text_iarchive(unsigned int flags)

inline ~basic_text_iarchive()

Friends

friend class detail::interface_iarchive< Archive >

template<class IStream>
class basic_text_iprimitive

#include <basic_text_iprimitive.hpp>

Public Functions

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

Protected Functions

template<class T>
inline void load(T &t)

inline void load(char &t)

inline void load(signed char &t)

inline void load(unsigned char &t)

inline void load(wchar_t &t)

basic_text_iprimitive(IStream &is, bool no_codecvt)

~basic_text_iprimitive()

Protected Attributes

IStream &is

boost::io::ios_flags_saver flags_saver

boost::io::ios_precision_saver precision_saver

boost::scoped_ptr<std::locale> archive_locale

basic_streambuf_locale_saver<typename IStream::char_type, typename IStream::traits_type> locale_saver

template<class Archive>
class basic_text_oarchive : public icecube::archive::detail::common_oarchive<Archive>

#include <basic_text_oarchive.hpp>

Subclassed by icecube::archive::text_oarchive_impl< Archive >, icecube::archive::text_woarchive_impl< Archive >

Protected Types

enum [anonymous]

Values:

enumerator none

enumerator eol

enumerator space

typedef detail::common_oarchive<Archive> detail_common_oarchive

Protected Functions

newtoken()

inline void newline()

template<class T>
inline void save_override(T &t, I3_PFTO int)

inline void save_override(const object_id_type &t, int)

inline void save_override(const class_id_optional_type&, int)

inline void save_override(const class_name_type &t, int)

init()

inline basic_text_oarchive(unsigned int flags)

inline ~basic_text_oarchive()

Protected Attributes

enum icecube::archive::basic_text_oarchive::[anonymous] delimiter

Friends

friend class detail::interface_oarchive< Archive >

template<class OStream>
class basic_text_oprimitive

#include <basic_text_oprimitive.hpp>

Public Functions

inline void put(typename OStream::char_type c)

inline void put(const char *s)

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

Protected Functions

inline void save(const bool t)

inline void save(const signed char t)

inline void save(const unsigned char t)

inline void save(const char t)

inline void save(const wchar_t t)

template<class T>
inline void save_impl(const T &t, boost::mpl::bool_<false>&)

template<class T>
inline void save_impl(const T &t, boost::mpl::bool_<true>&)

template<class T>
inline void save(const T &t)

basic_text_oprimitive(OStream &os, bool no_codecvt)

~basic_text_oprimitive()

Protected Attributes

OStream &os

boost::io::ios_flags_saver flags_saver

boost::io::ios_precision_saver precision_saver

boost::scoped_ptr<std::locale> archive_locale

basic_streambuf_locale_saver<typename OStream::char_type, typename OStream::traits_type> locale_saver

struct basic_traits

#include <traits.hpp>

Subclassed by icecube::serialization::traits< T, Level, Tracking, Version, ETII, Wrapper >, icecube::serialization::traits< const array< T >, Level, Tracking, Version, ETII, boost::mpl::true_ >, icecube::serialization::traits< const nvp< T >, Level, Tracking, Version, ETII, boost::mpl::true_ >, icecube::serialization::traits< ephemeral_object< T >, Level, Tracking, Version, ETII, boost::mpl::true_ >, icecube::serialization::traits< nvp< const binary_object >, Level, Tracking, Version, ETII, boost::mpl::true_ >, icecube::serialization::traits< T, Level, Tracking, Version, ETII, boost::mpl::true_ >

template<class CharType>
class basic_xml_grammar

#include <basic_xml_grammar.hpp>

Public Functions

bool parse_start_tag(IStream &is)

bool parse_end_tag(IStream &is) const

bool parse_string(IStream &is, StringType &s)

void init(IStream &is)

void windup(IStream &is)

basic_xml_grammar()

Public Members

struct icecube::archive::basic_xml_grammar::return_values rv

Private Types

BOOST_DEDUCED_TYPENAME std::basic_istream< CharType > IStream

BOOST_DEDUCED_TYPENAME std::basic_string< CharType > StringType

BOOST_DEDUCED_TYPENAME boost::spirit::classic::chset< CharType > chset_t

BOOST_DEDUCED_TYPENAME boost::spirit::classic::chlit< CharType > chlit_t

BOOST_DEDUCED_TYPENAME boost::spirit::classic::scanner< BOOST_DEDUCED_TYPENAME std::basic_string< CharType >::iterator > scanner_t

BOOST_DEDUCED_TYPENAME boost::spirit::classic::rule< scanner_t > rule_t

Private Functions

void init_chset()

bool my_parse(IStream &is, const rule_t &rule_, const CharType delimiter = L'>') const

Private Members

rule_t Reference

rule_t Eq

rule_t STag

rule_t ETag

rule_t LetterOrUnderscoreOrColon

rule_t AttValue

rule_t CharRef1

rule_t CharRef2

rule_t CharRef

rule_t AmpRef

rule_t LTRef

rule_t GTRef

rule_t AposRef

rule_t QuoteRef

rule_t CharData

rule_t CharDataChars

rule_t content

rule_t AmpName

rule_t LTName

rule_t GTName

rule_t ClassNameChar

rule_t ClassName

rule_t Name

rule_t XMLDecl

rule_t XMLDeclChars

rule_t DocTypeDecl

rule_t DocTypeDeclChars

rule_t ClassIDAttribute

rule_t ObjectIDAttribute

rule_t ClassNameAttribute

rule_t TrackingAttribute

rule_t VersionAttribute

rule_t UnusedAttribute

rule_t Attribute

rule_t SignatureAttribute

rule_t SerializationWrapper

rule_t NameHead

rule_t NameTail

rule_t AttributeList

rule_t S

chset_t BaseChar

chset_t Ideographic

chset_t Char

chset_t Letter

chset_t Digit

chset_t CombiningChar

chset_t Extender

chset_t Sch

chset_t NameChar

Friends

friend struct return_values

template<class Archive>
class basic_xml_iarchive : public icecube::archive::detail::common_iarchive<Archive>

#include <basic_xml_iarchive.hpp>

Subclassed by icecube::archive::xml_iarchive_impl< Archive >, icecube::archive::xml_wiarchive_impl< Archive >

Protected Types

typedef detail::common_iarchive<Archive> detail_common_iarchive

Protected Functions

load_start(const char *name)

load_end(const char *name)

template<class T>
inline void load_override(T &t, I3_PFTO int)

template<class T>
inline void load_override(const icecube::serialization::nvp<T> &t, int)

inline void load_override(class_id_optional_type&, int)

load_override(object_id_type &t, int)

load_override(version_type &t, int)

load_override(class_id_type &t, int)

load_override(tracking_type &t, int)

basic_xml_iarchive(unsigned int flags)

~basic_xml_iarchive()

Protected Attributes

unsigned int depth

Friends

friend class detail::interface_iarchive< Archive >

template<class Archive>
class basic_xml_oarchive : public icecube::archive::detail::common_oarchive<Archive>

#include <basic_xml_oarchive.hpp>

Subclassed by icecube::archive::xml_oarchive_impl< Archive >, icecube::archive::xml_woarchive_impl< Archive >

Protected Types

typedef detail::common_oarchive<Archive> detail_common_oarchive

Protected Functions

indent()

init()

write_attribute(const char *attribute_name, int t, const char *conjunction = "=\"")

write_attribute(const char *attribute_name, const char *key)

save_start(const char *name)

save_end(const char *name)

end_preamble()

template<class T>
inline void save_override(T &t, I3_PFTO int)

template<class T>
inline void save_override(const ::icecube::serialization::nvp<T> &t, int)

save_override(const object_id_type &t, int)

save_override(const object_reference_type &t, int)

save_override(const version_type &t, int)

save_override(const class_id_type &t, int)

save_override(const class_id_optional_type &t, int)

save_override(const class_id_reference_type &t, int)

save_override(const class_name_type &t, int)

save_override(const tracking_type &t, int)

basic_xml_oarchive(unsigned int flags)

~basic_xml_oarchive()

Protected Attributes

unsigned int depth

bool indent_next

bool pending_preamble

Friends

friend class detail::interface_oarchive< Archive >

friend class save_access

template<class Base, class CharType = typename boost::iterator_value<Base>::type>
class binary_from_base64 : public boost::transform_iterator<detail::to_6_bit<CharType>, Base>

#include <binary_from_base64.hpp>

Public Functions

template<class T> inline  binary_from_base64 (I3_PFTO_WRAPPER(T) start)

inline binary_from_base64(const binary_from_base64 &rhs)

Private Types

typedef boost::transform_iterator<detail::to_6_bit<CharType>, Base> super_t

class binary_iarchive : public icecube::archive::binary_iarchive_impl<icecube::archive::binary_iarchive, std::istream::char_type, std::istream::traits_type>

#include <binary_iarchive.hpp>

Subclassed by icecube::archive::detail::polymorphic_iarchive_route< binary_iarchive >

Public Functions

inline binary_iarchive(std::istream &is, unsigned int flags = 0)

inline binary_iarchive(std::streambuf &bsb, unsigned int flags = 0)

template<class Archive, class Elem, class Tr>
class binary_iarchive_impl : public icecube::archive::basic_binary_iprimitive<Archive, Elem, Tr>, public icecube::archive::basic_binary_iarchive<Archive>

#include <binary_iarchive_impl.hpp>

Protected Functions

template<class T>
inline void load_override(T &t, I3_PFTO int)

inline void init(unsigned int flags)

inline binary_iarchive_impl(std::basic_streambuf<Elem, Tr> &bsb, unsigned int flags)

inline binary_iarchive_impl(std::basic_istream<Elem, Tr> &is, unsigned int flags)

Friends

friend class detail::interface_iarchive< Archive >

friend class basic_binary_iarchive< Archive >

friend class load_access

class binary_oarchive : public icecube::archive::binary_oarchive_impl<binary_oarchive, std::ostream::char_type, std::ostream::traits_type>

#include <binary_oarchive.hpp>

Public Functions

inline binary_oarchive(std::ostream &os, unsigned int flags = 0)

inline binary_oarchive(std::streambuf &bsb, unsigned int flags = 0)

template<class Archive, class Elem, class Tr>
class binary_oarchive_impl : public icecube::archive::basic_binary_oprimitive<Archive, Elem, Tr>, public icecube::archive::basic_binary_oarchive<Archive>

#include <binary_oarchive_impl.hpp>

Protected Functions

template<class T>
inline void save_override(T &t, I3_PFTO int)

inline void init(unsigned int flags)

inline binary_oarchive_impl(std::basic_streambuf<Elem, Tr> &bsb, unsigned int flags)

inline binary_oarchive_impl(std::basic_ostream<Elem, Tr> &os, unsigned int flags)

Friends

friend class detail::interface_oarchive< Archive >

friend class basic_binary_oarchive< Archive >

friend class save_access

struct binary_object : public icecube::serialization::wrapper_traits<nvp<const binary_object>>

#include <binary_object.hpp>

Public Functions

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

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

inline binary_object &operator=(const binary_object &rhs)

inline binary_object(void *const t, std::size_t size)

inline binary_object(const binary_object &rhs)

Public Members

void const *m_t

std::size_t m_size

class binary_wiarchive : public icecube::archive::binary_iarchive_impl<binary_wiarchive, std::wistream::char_type, std::wistream::traits_type>

#include <binary_wiarchive.hpp>

Public Functions

inline binary_wiarchive(std::wistream &is, unsigned int flags = 0)

inline binary_wiarchive(std::wstreambuf &bsb, unsigned int flags = 0)

class binary_woarchive : public icecube::archive::binary_oarchive_impl<binary_woarchive, std::wostream::char_type, std::wostream::traits_type>

#include <binary_woarchive.hpp>

Public Functions

inline binary_woarchive(std::wostream &os, unsigned int flags = 0)

inline binary_woarchive(std::wstreambuf &bsb, unsigned int flags = 0)

class class_id_type

#include <basic_archive.hpp>

Public Functions

inline class_id_type()

inline explicit class_id_type(const int t_)

inline explicit class_id_type(const std::size_t t_)

inline class_id_type(const class_id_type &t_)

inline class_id_type &operator=(const class_id_type &rhs)

inline operator int() const

inline operator int_least16_t&()

inline bool operator==(const class_id_type &rhs) const

inline bool operator<(const class_id_type &rhs) const

Private Types

typedef int_least16_t base_type

Private Members

base_type t

struct class_name_type : private noncopyable

#include <basic_archive.hpp>

Public Functions

inline operator const char*&() const

inline operator char*()

inline std::size_t size() const

inline explicit class_name_type(const char *key_)

inline explicit class_name_type(char *key_)

inline class_name_type &operator=(const class_name_type &rhs)

Public Members

char *t

class cobject_id

Public Functions

inline cobject_id &operator=(const cobject_id &rhs)

inline cobject_id(const basic_iserializer &bis_)

inline cobject_id(const cobject_id &rhs)

Public Members

const basic_iserializer *bis_ptr

const basic_pointer_iserializer *bpis_ptr

version_type file_version

tracking_type tracking_level

bool initialized

struct cobject_type

Public Functions

inline cobject_type(std::size_t class_id, const basic_iserializer &bis)

inline cobject_type(const cobject_type &rhs)

cobject_type &operator=(const cobject_type &rhs)

inline bool operator<(const cobject_type &rhs) const

Public Members

const basic_iserializer *m_bis

const class_id_type m_class_id

struct cobject_type

Public Functions

inline cobject_type(std::size_t class_id, const basic_oserializer &bos)

inline cobject_type(const basic_oserializer &bos)

inline cobject_type(const cobject_type &rhs)

cobject_type &operator=(const cobject_type &rhs)

inline bool operator<(const cobject_type &rhs) const

Public Members

const basic_oserializer *m_bos_ptr

const class_id_type m_class_id

bool m_initialized

template<class Ch>
class codecvt_null

#include <codecvt_null.hpp>

template<>
class codecvt_null<char> : public std::codecvt<char, char, std::mbstate_t>

#include <codecvt_null.hpp>

Public Functions

inline explicit codecvt_null(std::size_t no_locale_manage = 0)

Private Functions

inline virtual bool do_always_noconv() const

template<>
class codecvt_null<wchar_t> : public std::codecvt<wchar_t, char, std::mbstate_t>

#include <codecvt_null.hpp>

Private Functions

inline virtual int do_max_length() const

class collection_size_type

#include <collection_size_type.hpp>

Public Functions

inline collection_size_type()

inline explicit collection_size_type(const std::size_t &t_)

inline collection_size_type(const collection_size_type &t_)

inline collection_size_type &operator=(const collection_size_type &rhs)

inline collection_size_type &operator=(const unsigned int &rhs)

inline operator base_type() const

inline operator base_type&()

inline bool operator==(const collection_size_type &rhs) const

inline bool operator<(const collection_size_type &rhs) const

Private Types

typedef std::size_t base_type

Private Members

base_type t

struct collection_type_compare

Public Functions

inline bool operator()(const boost::shared_ptr<const void> &lhs, const boost::shared_ptr<const void> &rhs) const

template<class Archive>
class common_iarchive : public basic_iarchive, public icecube::archive::detail::interface_iarchive<Archive>

#include <common_iarchive.hpp>

Subclassed by icecube::archive::basic_binary_iarchive< Archive >, icecube::archive::basic_text_iarchive< Archive >, icecube::archive::basic_xml_iarchive< Archive >

Protected Functions

template<class T>
inline void load_override(T &t, I3_PFTO int)

inline void load_start(const char*)

inline void load_end(const char*)

inline common_iarchive(unsigned int flags = 0)

Private Functions

inline virtual void vload(version_type &t)

inline virtual void vload(object_id_type &t)

inline virtual void vload(class_id_type &t)

inline virtual void vload(class_id_optional_type &t)

inline virtual void vload(tracking_type &t)

inline virtual void vload(class_name_type &s)

Friends

friend class interface_iarchive< Archive >

template<class Archive>
class common_oarchive : public basic_oarchive, public icecube::archive::detail::interface_oarchive<Archive>

#include <common_oarchive.hpp>

Subclassed by icecube::archive::basic_binary_oarchive< Archive >, icecube::archive::basic_text_oarchive< Archive >, icecube::archive::basic_xml_oarchive< Archive >

Protected Functions

template<class T>
inline void save_override(T &t, I3_PFTO int)

inline void save_start(const char*)

inline void save_end(const char*)

inline common_oarchive(unsigned int flags = 0)

Private Functions

inline virtual void vsave(const version_type t)

inline virtual void vsave(const object_id_type t)

inline virtual void vsave(const object_reference_type t)

inline virtual void vsave(const class_id_type t)

inline virtual void vsave(const class_id_reference_type t)

inline virtual void vsave(const class_id_optional_type t)

inline virtual void vsave(const class_name_type &t)

inline virtual void vsave(const tracking_type t)

Friends

friend class interface_oarchive< Archive >

struct const_cast_tag

#include <shared_ptr_132.hpp>

struct cross

#include <smart_cast.hpp>

Public Static Functions

template<class U>
static inline T cast(U &u)

template<class Derived>
class dataflow

#include <dataflow.hpp>

Public Functions

inline dataflow(bool tf)

inline dataflow()

Protected Functions

inline tri_state equal(const Derived &rhs) const

inline void eoi(bool tf)

inline bool eoi() const

Private Members

bool m_eoi

class dataflow_exception : public std::exception

#include <dataflow_exception.hpp>

Public Types

enum exception_code

Values:

enumerator invalid_6_bitcode

enumerator invalid_base64_character

enumerator invalid_xml_escape_sequence

enumerator comparison_not_permitted

enumerator invalid_conversion

enumerator other_exception

Public Functions

inline dataflow_exception(exception_code c = other_exception)

inline virtual const char *what() const

Public Members

exception_code code

struct defined

#include <extended_type_info_no_rtti.hpp>

Public Static Functions

static inline const char *invoke()

struct dynamic_cast_tag

#include <shared_ptr_132.hpp>

template<class T>
class enable_shared_from_this

#include <shared_ptr_132.hpp>

template<class T>
struct ephemeral_object : public icecube::serialization::wrapper_traits<ephemeral_object<T>>

#include <ephemeral.hpp>

Public Functions

inline explicit ephemeral_object(T &t)

inline T &value() const

inline const T &const_value() const

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

Private Members

T &val

template<class T>
struct error

#include <smart_cast.hpp>

Public Static Functions

template<class U>
static inline T cast(U u)

template<class Derived, class Base>
class escape : public boost::iterator_adaptor<Derived, Base, boost::iterator_value<Base>::type, boost::single_pass_traversal_tag, boost::iterator_value<Base>::type>

#include <escape.hpp>

Public Functions

inline escape(Base base)

Private Types

typedef boost::iterator_value<Base>::type base_value_type

typedef boost::iterator_reference<Base>::type reference_type

typedef boost::iterator_adaptor<Derived, Base, base_value_type, boost::single_pass_traversal_tag, base_value_type> super_t

typedef escape<Derived, Base> this_t

Private Functions

inline void dereference_impl()

inline reference_type dereference() const

inline bool equal(const this_t &rhs) const

inline void increment()

Private Members

const base_value_type *m_bnext

const base_value_type *m_bend

bool m_full

base_value_type m_current_value

template<class Archive, class Serializable>
struct export_impl

#include <export.hpp>

Public Static Functions

static inline const basic_pointer_iserializer &enable_load(boost::mpl::true_)

static inline const basic_pointer_oserializer &enable_save(boost::mpl::true_)

static inline void enable_load(boost::mpl::false_)

static inline void enable_save(boost::mpl::false_)

class extended_type_info_arg : public extended_type_info

Public Functions

inline extended_type_info_arg(const char *key)

inline ~extended_type_info_arg()

Private Functions

inline virtual bool is_less_than(const extended_type_info&) const

inline virtual bool is_equal(const extended_type_info&) const

inline virtual const char *get_debug_info() const

inline virtual void *construct(unsigned int, ...) const

inline virtual void destroy(void const*const) const

template<class T>
struct extended_type_info_impl

#include <extended_type_info_no_rtti.hpp>

Public Types

typedef icecube::serialization::extended_type_info_no_rtti<T> type

typedef icecube::serialization::extended_type_info_typeid<T> type

template<class T>
class extended_type_info_no_rtti : public extended_type_info_no_rtti_0, public icecube::serialization::singleton<extended_type_info_no_rtti<T>>

#include <extended_type_info_no_rtti.hpp>

Public Functions

inline extended_type_info_no_rtti()

inline ~extended_type_info_no_rtti()

inline const extended_type_info *get_derived_extended_type_info(const T &t) const

inline const char *get_key() const

inline virtual const char *get_debug_info() const

inline virtual void *construct(unsigned int count, ...) const

inline virtual void destroy(void const *const p) const

template<class T>
class extended_type_info_typeid : public extended_type_info_typeid_0, public icecube::serialization::singleton<extended_type_info_typeid<T>>

#include <extended_type_info_typeid.hpp>

Public Functions

inline extended_type_info_typeid()

inline ~extended_type_info_typeid()

inline const extended_type_info *get_derived_extended_type_info(const T &t) const

inline const char *get_key() const

inline virtual void *construct(unsigned int count, ...) const

inline virtual void destroy(void const *const p) const

class extended_type_info_typeid_arg : public extended_type_info_typeid_0

Public Functions

inline extended_type_info_typeid_arg(const std::type_info &ti)

inline ~extended_type_info_typeid_arg()

Private Functions

inline virtual void *construct(unsigned int, ...) const

inline virtual void destroy(void const*const) const

template<class Predicate, class Base>
class filter_iterator : public boost::iterator_adaptor<filter_iterator<Predicate, Base>, Base, boost::use_default, boost::single_pass_traversal_tag>

#include <remove_whitespace.hpp>

Public Functions

inline void increment()

inline filter_iterator(Base start)

inline filter_iterator()

Private Types

typedef boost::iterator_adaptor<filter_iterator<Predicate, Base>, Base, boost::use_default, boost::single_pass_traversal_tag> super_t

typedef filter_iterator<Predicate, Base> this_t

typedef super_t::reference reference_type

Private Functions

inline reference_type dereference_impl()

inline reference_type dereference() const

Private Members

Predicate m_predicate

bool m_full

template<class Archive, class T>
struct free_loader

#include <split_free.hpp>

Public Static Functions

static inline void invoke(Archive &ar, T &t, const unsigned int file_version)

template<class Archive, class T>
struct free_saver

#include <split_free.hpp>

Public Static Functions

static inline void invoke(Archive &ar, const T &t, const unsigned int file_version)

template<class CharType>
struct from_6_bit

#include <base64_from_binary.hpp>

Public Types

typedef CharType result_type

Public Functions

inline CharType operator()(CharType t) const

template<class T>
struct guid_defined : public false_

#include <extended_type_info.hpp>

template<typename T>
struct guid_impl

#include <extended_type_info.hpp>

Public Static Functions

static inline const char *call()

template<class T>
struct guid_initializer

#include <export.hpp>

Public Functions

inline void export_guid(boost::mpl::false_) const

inline void export_guid(boost::mpl::true_) const

inline guid_initializer const &export_guid() const

template<class Predicate, class Base>
class head_iterator : public boost::iterator_adaptor<head_iterator<Predicate, Base>, Base, use_default, single_pass_traversal_tag>

#include <head_iterator.hpp>

Public Functions

template<class T>
inline head_iterator(Predicate f, T start)

Private Types

typedef boost::iterator_adaptor<head_iterator<Predicate, Base>, Base, use_default, single_pass_traversal_tag> super_t

typedef head_iterator<Predicate, Base> this_t

typedef super_t::value_type value_type

typedef super_t::reference reference_type

Private Functions

inline reference_type dereference_impl()

inline reference_type dereference() const

inline void increment()

Private Members

Predicate m_predicate

bool m_end

Friends

friend class iterator_core_access

template<class T>
struct heap_allocation

#include <iserializer.hpp>

Public Functions

inline explicit heap_allocation()

inline ~heap_allocation()

inline T *get() const

inline T *release()

Public Static Functions

static inline T *invoke_new()

static inline void invoke_delete(T *t)

Private Members

T *m_p

class helper_collection

#include <helper_collection.hpp>

Public Functions

template<typename Helper>
inline Helper &get_helper(void *const id = 0)

Protected Functions

inline helper_collection()

inline ~helper_collection()

Private Types

typedef std::pair<const void*, boost::shared_ptr<void>> helper_value_type

typedef std::vector<helper_value_type> collection

Private Functions

helper_collection(const helper_collection&)

helper_collection &operator=(const helper_collection&)

template<class T>
inline boost::shared_ptr<void> make_helper_ptr()

Private Members

collection m_collection

template<int i>
struct I3_SERIALIZATION_SS

#include <static_warning.hpp>

template<int L>
struct I3_SERIALIZATION_STATIC_WARNING_LINE

#include <static_warning.hpp>

template<class T>
struct implementation_level : public icecube::serialization::implementation_level_impl<const T>

#include <level.hpp>

template<class T>
struct implementation_level<nvp<T>>

#include <nvp.hpp>

Public Types

typedef boost::mpl::integral_c_tag tag

typedef boost::mpl::int_<object_serializable> type

template<class T>
struct implementation_level<std::complex<T>> : public boost::mpl::int_<object_serializable>

#include <complex.hpp>

template<class T>
struct implementation_level_impl

#include <level.hpp>

Public Types

typedef boost::mpl::integral_c_tag tag

typedef boost::mpl::eval_if<boost::is_base_and_derived<icecube::serialization::basic_traits, T>, traits_class_level<T>, typename boost::mpl::eval_if<boost::is_fundamental<T>, boost::mpl::int_<primitive_type>, typename boost::mpl::eval_if<boost::is_class<T>, boost::mpl::int_<object_class_info>, typename boost::mpl::eval_if<boost::is_array<T>, boost::mpl::int_<object_serializable>, typename boost::mpl::eval_if<boost::is_enum<T>, boost::mpl::int_<primitive_type>, boost::mpl::int_<not_serializable>>>>>>::type type

template<typename T>
struct init_guid

#include <export.hpp>

template<class Base, int N, class CharType = typename boost::iterator_value<Base>::type>
class insert_linebreaks : public boost::iterator_adaptor<insert_linebreaks<Base, N, CharType>, Base, CharType, boost::single_pass_traversal_tag, CharType>

#include <insert_linebreaks.hpp>

Public Functions

template<class T> inline  insert_linebreaks (I3_PFTO_WRAPPER(T) start)

inline insert_linebreaks(const insert_linebreaks &rhs)

Private Types

typedef boost::iterator_adaptor<insert_linebreaks<Base, N, CharType>, Base, CharType, boost::single_pass_traversal_tag, CharType> super_t

Private Functions

inline bool equal(const insert_linebreaks<Base, N, CharType> &rhs) const

inline void increment()

inline CharType dereference() const

Private Members

unsigned int m_count

template<void (*)()>
struct instantiate_function

#include <export.hpp>

template<class Archive>
class interface_iarchive

#include <basic_binary_iarchive.hpp>

Subclassed by icecube::archive::detail::common_iarchive< Archive >

Public Types

typedef boost::mpl::bool_<true> is_loading

typedef boost::mpl::bool_<false> is_saving

Public Functions

inline Archive *This()

template<class T>
inline const basic_pointer_iserializer *register_type(T* = NULL)

template<class T>
inline Archive &operator>>(T &t)

template<class T>
inline Archive &operator&(T &t)

Protected Functions

inline interface_iarchive()

template<class Archive>
class interface_oarchive

#include <basic_binary_oarchive.hpp>

Subclassed by icecube::archive::detail::common_oarchive< Archive >

Public Types

typedef boost::mpl::bool_<false> is_loading

typedef boost::mpl::bool_<true> is_saving

Public Functions

inline Archive *This()

template<class T>
inline const basic_pointer_oserializer *register_type(const T* = NULL)

template<class T>
inline Archive &operator<<(T &t)

template<class T>
inline Archive &operator&(T &t)

Protected Functions

inline interface_oarchive()

template<class T>
struct is_abstract : public boost::is_abstract<T>

#include <assume_abstract.hpp>

template<class T>
struct is_bitwise_serializable : public boost::is_arithmetic<T>

#include <is_bitwise_serializable.hpp>

Subclassed by icecube::archive::basic_binary_iprimitive< Archive, Elem, Tr >::use_array_optimization::apply< T >, icecube::archive::basic_binary_oprimitive< Archive, Elem, Tr >::use_array_optimization::apply< T >, icecube::archive::portable_binary_iarchive::use_array_optimization::apply< T >, icecube::archive::portable_binary_oarchive::use_array_optimization::apply< T >, icecube::serialization::is_bitwise_serializable< std::complex< T > >

template<class T>
struct is_bitwise_serializable<std::complex<T>> : public icecube::serialization::is_bitwise_serializable<T>

#include <complex.hpp>

template<class T, class U>
struct is_bitwise_serializable<std::pair<T, U>> : public boost::mpl::and_<is_bitwise_serializable<T>, is_bitwise_serializable<U>>

#include <utility.hpp>

specialization of is_bitwise_serializable for pairs

template<class T>
struct is_float

#include <basic_text_oprimitive.hpp>

Public Types

typedef boost::mpl::bool_<boost::is_floating_point<T>::value || (std::numeric_limits<T>::is_specialized && !std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_exact && std::numeric_limits<T>::max_exponent)>::type type

template<class T>
struct is_wrapper

#include <wrapper.hpp>

Public Types

typedef is_wrapper_impl<const T>::type type

template<class T>
struct is_wrapper_impl : public boost::mpl::eval_if::type<boost::is_base_and_derived<basic_traits, T>, boost::mpl::true_, boost::mpl::false_>

#include <wrapper.hpp>

template<class Archive, class T>
class iserializer : public basic_iserializer

#include <iserializer.hpp>

Public Functions

virtual I3_DLLEXPORT void load_object_data (basic_iarchive &ar, void *x, const unsigned int file_version) const I3_SERIALIZATION_USED

inline virtual bool class_info() const

inline virtual bool tracking(const unsigned int) const

inline virtual version_type version() const

inline virtual bool is_polymorphic() const

inline virtual ~iserializer()

Protected Functions

inline explicit iserializer()

Private Functions

inline virtual void destroy(void *address) const

template<class Elem = char>
class istream_iterator : public boost::iterator_facade<istream_iterator<Elem>, Elem, std::input_iterator_tag, Elem>

#include <istream_iterator.hpp>

Public Functions

inline istream_iterator(istream_type &is)

inline istream_iterator()

inline istream_iterator(const istream_iterator<Elem> &rhs)

Private Types

typedef istream_iterator this_t

typedef boost::iterator_facade<istream_iterator<Elem>, Elem, std::input_iterator_tag, Elem> super_t

typedef std::basic_istream<Elem> istream_type

Private Functions

inline bool equal(const this_t &rhs) const

inline Elem dereference() const

inline void increment()

Private Members

istream_type *m_istream

Elem m_current_value

class item_version_type

#include <item_version_type.hpp>

Public Functions

inline item_version_type()

inline explicit item_version_type(const unsigned int t_)

inline item_version_type(const item_version_type &t_)

inline item_version_type &operator=(item_version_type rhs)

inline operator base_type() const

inline operator base_type&()

inline bool operator==(const item_version_type &rhs) const

inline bool operator<(const item_version_type &rhs) const

Private Types

typedef unsigned int base_type

Private Members

base_type t

struct key_compare

Public Functions

inline bool operator()(const extended_type_info *lhs, const extended_type_info *rhs) const

class library_version_type

#include <basic_archive.hpp>

Public Functions

inline library_version_type()

inline explicit library_version_type(const unsigned int &t_)

inline library_version_type(const library_version_type &t_)

inline library_version_type &operator=(const library_version_type &rhs)

inline operator base_type() const

inline operator base_type&()

inline bool operator==(const library_version_type &rhs) const

inline bool operator<(const library_version_type &rhs) const

Private Types

typedef uint_least16_t base_type

Private Members

base_type t

struct linear

#include <smart_cast.hpp>

Public Static Functions

template<class U>
static inline T cast(U &u)

class load_access

#include <iserializer.hpp>

Public Static Functions

template<class Archive, class T>
static inline void load_primitive(Archive &ar, T &t)

template<class Archive>
struct load_array_type

#include <iserializer.hpp>

Public Static Functions

template<class T>
static inline void invoke(Archive &ar, T &t)

struct load_conditional

#include <iserializer.hpp>

Public Static Functions

template<class T>
static inline void invoke(Archive &ar, T &t)

template<class Archive>
struct load_enum_type

#include <iserializer.hpp>

Public Static Functions

template<class T>
static inline void invoke(Archive &ar, T &t)

struct load_impl

#include <variant.hpp>

Public Static Functions

template<class Archive, class V>
static inline void invoke(Archive &ar, int which, V &v, const unsigned int version)

template<class Archive>
struct load_non_pointer_type

#include <iserializer.hpp>

Public Static Functions

template<class T>
static inline void invoke(Archive &ar, T &t)

struct load_null

#include <variant.hpp>

Public Static Functions

template<class Archive, class V>
static inline void invoke(Archive&, int, V&, const unsigned int)

struct load_only

#include <iserializer.hpp>

Public Static Functions

template<class T>
static inline void invoke(Archive &ar, const T &t)

template<class Archive>
struct load_pointer_type

#include <iserializer.hpp>

Public Static Functions

template<class T>
static inline const basic_pointer_iserializer *register_type(Archive &ar, const T&)

template<class T>
static inline T *pointer_tweak(const icecube::serialization::extended_type_info &eti, void const *const t, const T&)

template<class T>
static inline void check_load(T&)

static inline const basic_pointer_iserializer *find(const icecube::serialization::extended_type_info &type)

template<class Tptr>
static inline void invoke(Archive &ar, Tptr &t)

struct load_primitive

#include <iserializer.hpp>

Public Static Functions

template<class T>
static inline void invoke(Archive &ar, T &t)

struct load_standard

#include <iserializer.hpp>

Public Static Functions

template<class T>
static inline void invoke(Archive &ar, const T &t)

template<class Base>
class mb_from_wchar : public boost::iterator_adaptor<mb_from_wchar<Base>, Base, wchar_t, boost::single_pass_traversal_tag, char>

#include <mb_from_wchar.hpp>

Public Functions

template<class T> inline  mb_from_wchar (I3_PFTO_WRAPPER(T) start)

inline mb_from_wchar(const mb_from_wchar &rhs)

Private Types

typedef boost::iterator_adaptor<mb_from_wchar<Base>, Base, wchar_t, boost::single_pass_traversal_tag, char> super_t

typedef mb_from_wchar<Base> this_t

Private Functions

inline char dereference_impl()

inline char dereference() const

inline bool equal(const mb_from_wchar<Base> &rhs) const

inline void fill()

inline void increment()

Private Members

int m_bend

int m_bnext

char m_buffer[9]

bool m_full

template<class Archive, class T>
struct member_loader

#include <access.hpp>

Public Static Functions

static inline void invoke(Archive &ar, T &t, const unsigned int file_version)

template<class Archive, class T>
struct member_saver

#include <access.hpp>

Public Static Functions

static inline void invoke(Archive &ar, const T &t, const unsigned int file_version)

struct moveable_objects

Public Functions

inline moveable_objects()

Public Members

object_id_type start

object_id_type end

object_id_type recent

bool is_pointer

template<class Container>
class no_reserve_imp

#include <collections_load_imp.hpp>

Public Functions

inline void operator()(Container&, std::size_t) const

struct non_abstract

#include <iserializer.hpp>

Public Static Functions

template<class T>
static inline const basic_pointer_iserializer *register_type(Archive &ar)

struct non_abstract

#include <oserializer.hpp>

Public Static Functions

template<class T>
static inline const basic_pointer_oserializer *register_type(Archive &ar)

struct non_polymorphic

#include <base_object.hpp>

Public Static Functions

static inline void const *invoke()

struct non_polymorphic

Public Static Functions

template<class U>
static inline const icecube::serialization::extended_type_info *get_object_type(U&)

struct non_polymorphic

#include <smart_cast.hpp>

Public Static Functions

template<class U>
static inline T cast(U &u)

struct non_polymorphic

#include <smart_cast.hpp>

Public Static Functions

template<class U>
static inline T cast(U *u)

struct non_polymorphic

#include <oserializer.hpp>

Public Static Functions

template<class T>
static inline void save(Archive &ar, T &t)

template<class T>
struct non_polymorphic

Public Static Functions

static inline const icecube::serialization::extended_type_info *get_object_identifier(T&)

struct null_deleter

#include <shared_ptr.hpp>

Public Functions

inline void operator()(void const*) const

struct null_deleter

#include <shared_ptr_132.hpp>

Public Functions

inline void operator()(void const*) const

struct null_deleter

Public Functions

inline void operator()(void const*) const

struct null_deleter

Public Functions

inline void operator()(void const*) const

template<class T>
struct nvp : public std::pair<const char*, T*>, public icecube::serialization::wrapper_traits<const nvp<T>>

#include <nvp.hpp>

Public Functions

inline explicit nvp(const char *name_, T &t)

inline nvp(const nvp &rhs)

inline const char *name() const

inline T &value() const

inline const T &const_value() const

template<class Archivex>
inline void save(Archivex &ar, const unsigned int) const

template<class Archivex>
inline void load(Archivex &ar, const unsigned int)

class object_id_type

#include <basic_archive.hpp>

Public Functions

inline object_id_type()

inline explicit object_id_type(const std::size_t &t_)

inline object_id_type(const object_id_type &t_)

inline object_id_type &operator=(const object_id_type &rhs)

inline operator uint_least32_t() const

inline operator uint_least32_t&()

inline bool operator==(const object_id_type &rhs) const

inline bool operator<(const object_id_type &rhs) const

Private Types

typedef uint_least32_t base_type

Private Members

base_type t

template<class Archive, class T>
class oserializer : public basic_oserializer

#include <oserializer.hpp>

Public Functions

inline explicit I3_DLLEXPORT oserializer()

virtual I3_DLLEXPORT void save_object_data (basic_oarchive &ar, const void *x) const I3_SERIALIZATION_USED

inline virtual bool class_info() const

inline virtual bool tracking(const unsigned int) const

inline virtual version_type version() const

inline virtual bool is_polymorphic() const

inline virtual ~oserializer()

template<class Elem>
class ostream_iterator : public boost::iterator_facade<ostream_iterator<Elem>, Elem, std::output_iterator_tag, ostream_iterator<Elem>&>

#include <ostream_iterator.hpp>

Public Functions

inline this_t &operator=(char_type c)

inline ostream_iterator(ostream_type &os)

inline ostream_iterator()

inline ostream_iterator(const ostream_iterator &rhs)

Protected Functions

inline void put_val(char_type e)

Protected Attributes

ostream_type *m_ostream

Private Types

typedef ostream_iterator this_t

typedef Elem char_type

typedef std::basic_ostream<char_type> ostream_type

Private Functions

inline ostream_iterator &dereference() const

inline bool equal(const this_t &rhs) const

inline void increment()

struct pending

Public Functions

inline pending()

Public Members

void *object

const basic_iserializer *bis

version_type version

template<class T>
struct pfto_wrapper

#include <pfto.hpp>

Public Functions

inline operator const T&()

inline pfto_wrapper(const T &rhs)

Public Members

const T &t

template<class T>
struct pointer

#include <smart_cast.hpp>

Public Static Functions

template<class U>
static inline T cast(U *u)

template<class Archive, class T>
class pointer_iserializer : public basic_pointer_iserializer

#include <iserializer.hpp>

Protected Functions

pointer_iserializer()

~pointer_iserializer()

Private Functions

inline virtual void *heap_allocation() const

inline virtual const basic_iserializer &get_basic_serializer() const

virtual I3_DLLEXPORT void load_object_ptr (basic_iarchive &ar, void *x, const unsigned int file_version) const I3_SERIALIZATION_USED

template<class Archive, class T>
class pointer_oserializer : public basic_pointer_oserializer

#include <oserializer.hpp>

Public Functions

pointer_oserializer()

~pointer_oserializer()

Private Functions

inline const basic_oserializer &get_basic_serializer() const

virtual I3_DLLEXPORT void save_object_ptr (basic_oarchive &ar, const void *x) const I3_SERIALIZATION_USED

struct polymorphic

#include <base_object.hpp>

Public Static Functions

static inline void const *invoke()

template<class T>
struct polymorphic

Public Static Functions

static inline const icecube::serialization::extended_type_info *get_object_identifier(T &t)

struct polymorphic

Public Static Functions

template<class U>
static inline const icecube::serialization::extended_type_info *get_object_type(U &u)

struct polymorphic

#include <smart_cast.hpp>

Public Static Functions

template<class U>
static inline T cast(U &u)

struct polymorphic

#include <oserializer.hpp>

Public Static Functions

template<class T>
static inline void save(Archive &ar, T &t)

struct polymorphic

#include <smart_cast.hpp>

Public Static Functions

template<class U>
static inline T cast(U *u)

class polymorphic_binary_iarchive : public icecube::archive::detail::polymorphic_iarchive_route<binary_iarchive>

#include <polymorphic_binary_iarchive.hpp>

Public Functions

inline polymorphic_binary_iarchive(std::istream &is, unsigned int flags = 0)

inline ~polymorphic_binary_iarchive()

struct polymorphic_cast_tag

#include <shared_ptr_132.hpp>

class polymorphic_iarchive : public icecube::archive::polymorphic_iarchive_impl

#include <polymorphic_iarchive.hpp>

Subclassed by icecube::archive::detail::polymorphic_iarchive_route< ArchiveImplementation >, icecube::archive::detail::polymorphic_iarchive_route< binary_iarchive >, icecube::archive::detail::polymorphic_iarchive_route< text_iarchive >, icecube::archive::detail::polymorphic_iarchive_route< text_wiarchive >, icecube::archive::detail::polymorphic_iarchive_route< xml_iarchive >, icecube::archive::detail::polymorphic_iarchive_route< xml_wiarchive >

Public Functions

inline virtual ~polymorphic_iarchive()

class polymorphic_iarchive_impl : public icecube::archive::detail::interface_iarchive<polymorphic_iarchive>

#include <polymorphic_iarchive.hpp>

Subclassed by icecube::archive::polymorphic_iarchive

Public Functions

virtual void set_library_version(library_version_type archive_library_version) = 0

virtual library_version_type get_library_version() const = 0

virtual unsigned int get_flags() const = 0

virtual void delete_created_pointers() = 0

virtual void reset_object_address(const void *new_address, const void *old_address) = 0

virtual void load_binary(void *t, std::size_t size) = 0

virtual void load_object(void *t, const detail::basic_iserializer &bis) = 0

virtual const detail::basic_pointer_iserializer *load_pointer(void *&t, const detail::basic_pointer_iserializer *bpis_ptr, const detail::basic_pointer_iserializer *(*finder)(const icecube::serialization::extended_type_info &type)) = 0

Protected Functions

inline virtual ~polymorphic_iarchive_impl()

Private Functions

virtual void load(bool &t) = 0

virtual void load(char &t) = 0

virtual void load(signed char &t) = 0

virtual void load(unsigned char &t) = 0

virtual void load(wchar_t &t) = 0

virtual void load(short &t) = 0

virtual void load(unsigned short &t) = 0

virtual void load(int &t) = 0

virtual void load(unsigned int &t) = 0

virtual void load(long &t) = 0

virtual void load(unsigned long &t) = 0

virtual void load(float &t) = 0

virtual void load(double &t) = 0

virtual void load(std::string &t) = 0

virtual void load(std::wstring &t) = 0

virtual void load_start(const char *name) = 0

virtual void load_end(const char *name) = 0

virtual void register_basic_serializer(const detail::basic_iserializer &bis) = 0

template<class T>
inline void load_override(T &t, I3_PFTO int)

template<class T>
inline void load_override(const icecube::serialization::nvp<T> &t, int)

Friends

friend class detail::interface_iarchive< polymorphic_iarchive >

friend class load_access

template<class ArchiveImplementation>
class polymorphic_iarchive_route : public icecube::archive::polymorphic_iarchive, public ArchiveImplementation

#include <polymorphic_iarchive_route.hpp>

Public Types

typedef boost::mpl::bool_<true> is_loading

typedef boost::mpl::bool_<false> is_saving

Public Functions

template<class T>
inline polymorphic_iarchive &operator>>(T &t)

template<class T>
inline polymorphic_iarchive &operator&(T &t)

template<class T>
inline const basic_pointer_iserializer *register_type(T *t = NULL)

template<class _Elem, class _Tr>
inline polymorphic_iarchive_route(std::basic_istream<_Elem, _Tr> &is, unsigned int flags = 0)

inline virtual ~polymorphic_iarchive_route()

Private Functions

inline virtual void load_object(void *t, const basic_iserializer &bis)

inline virtual const basic_pointer_iserializer *load_pointer(void *&t, const basic_pointer_iserializer *bpis_ptr, const basic_pointer_iserializer *(*finder)(const icecube::serialization::extended_type_info &type))

inline virtual void set_library_version(library_version_type archive_library_version)

inline virtual library_version_type get_library_version() const

inline virtual unsigned int get_flags() const

inline virtual void delete_created_pointers()

inline virtual void reset_object_address(const void *new_address, const void *old_address)

inline virtual void load_binary(void *t, std::size_t size)

inline virtual void load(bool &t)

inline virtual void load(char &t)

inline virtual void load(signed char &t)

inline virtual void load(unsigned char &t)

inline virtual void load(wchar_t &t)

inline virtual void load(short &t)

inline virtual void load(unsigned short &t)

inline virtual void load(int &t)

inline virtual void load(unsigned int &t)

inline virtual void load(long &t)

inline virtual void load(unsigned long &t)

inline virtual void load(float &t)

inline virtual void load(double &t)

inline virtual void load(std::string &t)

inline virtual void load(std::wstring &t)

inline virtual void load_start(const char *name)

inline virtual void load_end(const char *name)

inline virtual void register_basic_serializer(const basic_iserializer &bis)

class polymorphic_oarchive : public icecube::archive::polymorphic_oarchive_impl

#include <polymorphic_oarchive.hpp>

Subclassed by icecube::archive::detail::polymorphic_oarchive_route< ArchiveImplementation >

Public Functions

inline virtual ~polymorphic_oarchive()

class polymorphic_oarchive_impl : public icecube::archive::detail::interface_oarchive<polymorphic_oarchive>

#include <polymorphic_oarchive.hpp>

Subclassed by icecube::archive::polymorphic_oarchive

Public Functions

virtual unsigned int get_flags() const = 0

virtual library_version_type get_library_version() const = 0

virtual void save_binary(const void *t, std::size_t size) = 0

virtual void save_object(const void *x, const detail::basic_oserializer &bos) = 0

virtual void save_pointer(const void *t, const detail::basic_pointer_oserializer *bpos_ptr) = 0

Protected Functions

inline virtual ~polymorphic_oarchive_impl()

Private Functions

virtual void save(const bool t) = 0

virtual void save(const char t) = 0

virtual void save(const signed char t) = 0

virtual void save(const unsigned char t) = 0

virtual void save(const wchar_t t) = 0

virtual void save(const short t) = 0

virtual void save(const unsigned short t) = 0

virtual void save(const int t) = 0

virtual void save(const unsigned int t) = 0

virtual void save(const long t) = 0

virtual void save(const unsigned long t) = 0

virtual void save(const float t) = 0

virtual void save(const double t) = 0

virtual void save(const std::string &t) = 0

virtual void save(const std::wstring &t) = 0

virtual void save_null_pointer() = 0

virtual void save_start(const char *name) = 0

virtual void save_end(const char *name) = 0

virtual void register_basic_serializer(const detail::basic_oserializer &bos) = 0

virtual void end_preamble() = 0

template<class T>
inline void save_override(T &t, I3_PFTO int)

template<class T>
inline void save_override(const ::icecube::serialization::nvp<T> &t, int)

Friends

friend class detail::interface_oarchive< polymorphic_oarchive >

friend class save_access

template<class ArchiveImplementation>
class polymorphic_oarchive_route : public icecube::archive::polymorphic_oarchive, public ArchiveImplementation

#include <polymorphic_oarchive_route.hpp>

Public Types

typedef boost::mpl::bool_<false> is_loading

typedef boost::mpl::bool_<true> is_saving

Public Functions

template<class T>
inline polymorphic_oarchive &operator<<(T &t)

template<class T>
inline polymorphic_oarchive &operator&(T &t)

template<class T>
inline const basic_pointer_oserializer *register_type(T *t = NULL)

template<class _Elem, class _Tr>
inline polymorphic_oarchive_route(std::basic_ostream<_Elem, _Tr> &os, unsigned int flags = 0)

inline virtual ~polymorphic_oarchive_route()

Private Functions

inline virtual void save_object(const void *x, const detail::basic_oserializer &bos)

inline virtual void save_pointer(const void *t, const detail::basic_pointer_oserializer *bpos_ptr)

inline virtual void save_null_pointer()

inline virtual void save(const bool t)

inline virtual void save(const char t)

inline virtual void save(const signed char t)

inline virtual void save(const unsigned char t)

inline virtual void save(const wchar_t t)

inline virtual void save(const short t)

inline virtual void save(const unsigned short t)

inline virtual void save(const int t)

inline virtual void save(const unsigned int t)

inline virtual void save(const long t)

inline virtual void save(const unsigned long t)

inline virtual void save(const float t)

inline virtual void save(const double t)

inline virtual void save(const std::string &t)

inline virtual void save(const std::wstring &t)

inline virtual library_version_type get_library_version() const

inline virtual unsigned int get_flags() const

inline virtual void save_binary(const void *t, std::size_t size)

inline virtual void save_start(const char *name)

inline virtual void save_end(const char *name)

inline virtual void end_preamble()

inline virtual void register_basic_serializer(const detail::basic_oserializer &bos)

class polymorphic_text_iarchive : public icecube::archive::detail::polymorphic_iarchive_route<text_iarchive>

#include <polymorphic_text_iarchive.hpp>

Public Functions

inline polymorphic_text_iarchive(std::istream &is, unsigned int flags = 0)

inline ~polymorphic_text_iarchive()

class polymorphic_text_wiarchive : public icecube::archive::detail::polymorphic_iarchive_route<text_wiarchive>

#include <polymorphic_text_wiarchive.hpp>

Public Functions

inline polymorphic_text_wiarchive(std::wistream &is, unsigned int flags = 0)

inline ~polymorphic_text_wiarchive()

class polymorphic_xml_iarchive : public icecube::archive::detail::polymorphic_iarchive_route<xml_iarchive>

#include <polymorphic_xml_iarchive.hpp>

Public Functions

inline polymorphic_xml_iarchive(std::istream &is, unsigned int flags = 0)

inline ~polymorphic_xml_iarchive()

class polymorphic_xml_wiarchive : public icecube::archive::detail::polymorphic_iarchive_route<xml_wiarchive>

#include <polymorphic_xml_wiarchive.hpp>

Public Functions

inline polymorphic_xml_wiarchive(std::wistream &is, unsigned int flags = 0)

inline ~polymorphic_xml_wiarchive()

class portable_binary_iarchive : public icecube::archive::detail::common_iarchive<portable_binary_iarchive>, public icecube::archive::detail::shared_ptr_helper

#include <portable_binary_archive.hpp>

Public Functions

inline portable_binary_iarchive(std::istream &stream, unsigned int flags = icecube::archive::no_header)

template<class T> inline void load_override (T &t, I3_PFTO int version)

inline void load_override(class_id_optional_type&, int)

inline void load_override(bool &t, I3_PFTO int)

void load_override(version_type &t, int)

ld_override (class_id_type, size_t, size_t, int16_t) ld_override(class_id_reference_type

int16_t ld_override (object_id_type, unsigned int, unsigned int, uint32_t) ld_override(object_reference_type

int16_t unsigned uint32_t void load_override (serialization::collection_size_type &t, int)

inline void load_override(tracking_type &t, int)

void load_override(std::string &s, I3_PFTO int)

void load_override(std::wstring &s, I3_PFTO int)

inline void load_override(class_name_type &t, I3_PFTO int)

template<class T>
inline void load_array(serialization::array<T> &a, unsigned int v)

inline void load_array(serialization::array<char> &a, unsigned int)

inline void load_binary(void *address, size_t count)

Public Members

class_id_type

size_t

int16_t object_id_type

int16_t unsigned int

Private Functions

template<class T>
inline void load(T &t)

Private Members

std::streambuf &is

Friends

friend class load_access

class portable_binary_oarchive : public icecube::archive::detail::common_oarchive<portable_binary_oarchive>, public icecube::archive::detail::shared_ptr_helper

#include <portable_binary_archive.hpp>

Public Functions

inline portable_binary_oarchive(std::ostream &stream, unsigned int flags = icecube::archive::no_header)

template<class T> inline void save_override (const T &t, I3_PFTO int version)

inline void save_override(const class_id_optional_type&, int)

inline void save_override(const bool &t, I3_PFTO int)

void save_override(const version_type &t, I3_PFTO int)

sv_override (class_id_type, int16_t) sv_override(class_id_reference_type

int16_t sv_override (object_id_type, uint32_t) sv_override(object_reference_type

int16_t uint32_t void save_override (const serialization::collection_size_type &t, I3_PFTO int)

void save_override(const class_name_type &t, I3_PFTO int)

template<class T>
inline void save_array(serialization::array<T> const &a, unsigned int v)

inline void save_array(serialization::array<char> const &a, unsigned int)

inline void save_binary(const void *address, size_t count)

Private Functions

template<class T>
inline void save(const T &t)

Private Members

std::streambuf &os

Friends

friend class save_access

struct predicate

Public Functions

inline bool operator()(helper_value_type const &rhs) const

inline predicate(const void *ti)

Public Members

const void *const m_ti

template<typename U, typename Container, typename Compare>
struct priority_queue_load : public STD::priority_queue<U, Container, Compare>

#include <priority_queue.hpp>

Public Functions

template<class Archive>
inline void operator()(Archive &ar, const unsigned int file_version)

template<typename U, typename Container, typename Compare>
struct priority_queue_save : public STD::priority_queue<U, Container, Compare>

#include <priority_queue.hpp>

Public Functions

template<class Archive>
inline void operator()(Archive &ar, const unsigned int file_version) const

template<class Archive, class Serializable>
struct ptr_serialization_support

#include <register_archive.hpp>

Subclassed by icecube::archive::detail::_ptr_serialization_support< Archive, Serializable >

Public Types

typedef instantiate_function<&ptr_serialization_support::instantiate> x

Public Static Functions

static I3_DLLEXPORT void instantiate () I3_SERIALIZATION_USED

template<typename U, typename C>
struct queue_load : public STD::queue<U, C>

#include <queue.hpp>

Public Functions

template<class Archive>
inline void operator()(Archive &ar, const unsigned int file_version)

template<typename U, typename C>
struct queue_save : public STD::queue<U, C>

#include <queue.hpp>

Public Functions

template<class Archive>
inline void operator()(Archive &ar, const unsigned int file_version) const

template<class T>
struct reference

#include <smart_cast.hpp>

Public Static Functions

template<class U>
static inline T cast(U &u)

template<class Base>
class remove_whitespace : public icecube::archive::iterators::filter_iterator<remove_whitespace_predicate<boost::iterator_value<Base>::type>, Base>

#include <remove_whitespace.hpp>

Public Functions

template<class T> inline  remove_whitespace (I3_PFTO_WRAPPER(T) start)

inline remove_whitespace(const remove_whitespace &rhs)

Private Types

typedef filter_iterator<remove_whitespace_predicate<typename boost::iterator_value<Base>::type>, Base> super_t

template<class Container>
class reserve_imp

#include <collections_load_imp.hpp>

Public Functions

inline void operator()(Container &s, std::size_t count) const

struct restore

Public Static Functions

static inline void invoke(T &previous_ref, const T &previous_value)

struct restore_with_exception

Public Static Functions

static inline void invoke(T &previous_ref, const T &previous_value)

struct return_values

#include <basic_xml_grammar.hpp>

Public Functions

inline return_values()

Public Members

StringType object_name

StringType contents

int_least16_t class_id

uint_least32_t object_id

unsigned int version

tracking_type tracking_level

StringType class_name

class save_access

#include <oserializer.hpp>

Public Static Functions

template<class Archive>
static inline void end_preamble(Archive &ar)

template<class Archive, class T>
static inline void save_primitive(Archive &ar, const T &t)

template<class Archive>
struct save_array_type

#include <oserializer.hpp>

Public Static Functions

template<class T>
static inline void invoke(Archive &ar, const T &t)

struct save_conditional

#include <oserializer.hpp>

Public Static Functions

template<class T>
static inline void invoke(Archive &ar, const T &t)

template<class Archive>
struct save_enum_type

#include <oserializer.hpp>

Public Static Functions

template<class T>
static inline void invoke(Archive &ar, const T &t)

template<class Archive>
struct save_non_pointer_type

#include <oserializer.hpp>

Public Static Functions

template<class T>
static inline void invoke(Archive &ar, const T &t)

template<class T>
static inline void invoke(Archive &ar, T &t)

struct save_only

#include <oserializer.hpp>

Public Static Functions

template<class T>
static inline void invoke(Archive &ar, const T &t)

template<class Archive>
struct save_pointer_type

#include <oserializer.hpp>

Public Static Functions

template<class T>
static inline const basic_pointer_oserializer *register_type(Archive &ar, T*)

template<class T>
static inline void save(Archive &ar, const T &t)

template<class TPtr>
static inline void invoke(Archive &ar, const TPtr t)

struct save_primitive

#include <oserializer.hpp>

Public Static Functions

template<class T>
static inline void invoke(Archive &ar, const T &t)

struct save_standard

#include <oserializer.hpp>

Public Static Functions

template<class T>
static inline void invoke(Archive &ar, const T &t)

class shared_count

#include <shared_count_132.hpp>

Public Functions

inline shared_count()

template<class P, class D>
inline shared_count(P p, D d)

inline ~shared_count()

inline shared_count(shared_count const &r)

inline explicit shared_count(weak_count const &r)

inline shared_count &operator=(shared_count const &r)

inline void swap(shared_count &r)

inline long use_count() const

inline bool unique() const

inline void *get_deleter(std::type_info const &ti) const

Public Members

sp_counted_base *pi_

Friends

friend class weak_count

inline friend bool operator==(shared_count const &a, shared_count const &b)

inline friend bool operator<(shared_count const &a, shared_count const &b)

template<class T>
class shared_ptr

#include <shared_ptr_helper.hpp>

Public Types

typedef T element_type

typedef T value_type

typedef T *pointer

typedef detail::shared_ptr_traits<T>::reference reference

typedef T *this_type::* unspecified_bool_type

Public Functions

inline shared_ptr()

template<class Y>
inline explicit shared_ptr(Y *p)

template<class Y, class D>
inline shared_ptr(Y *p, D d)

template<class Y>
inline explicit shared_ptr(weak_ptr<Y> const &r)

template<class Y>
inline shared_ptr(shared_ptr<Y> const &r)

template<class Y>
inline shared_ptr(shared_ptr<Y> const &r, detail::static_cast_tag)

template<class Y>
inline shared_ptr(shared_ptr<Y> const &r, detail::const_cast_tag)

template<class Y>
inline shared_ptr(shared_ptr<Y> const &r, detail::dynamic_cast_tag)

template<class Y>
inline shared_ptr(shared_ptr<Y> const &r, detail::polymorphic_cast_tag)

template<class Y>
inline shared_ptr &operator=(shared_ptr<Y> const &r)

inline void reset()

template<class Y>
inline void reset(Y *p)

template<class Y, class D>
inline void reset(Y *p, D d)

inline reference operator*() const

inline T *operator->() const

inline T *get() const

inline operator unspecified_bool_type() const

inline bool operator!() const

inline bool unique() const

inline long use_count() const

inline void swap(shared_ptr<T> &other)

template<class Y>
inline bool _internal_less(shared_ptr<Y> const &rhs) const

inline void *_internal_get_deleter(std::type_info const &ti) const

Public Members

T *px

detail::shared_count pn

Private Types

typedef shared_ptr<T> this_type

Friends

friend class shared_ptr

friend class weak_ptr

class shared_ptr_helper

#include <shared_ptr_helper.hpp>

Subclassed by icecube::archive::portable_binary_iarchive, icecube::archive::portable_binary_oarchive

Public Functions

template<class T>
inline void reset(boost::shared_ptr<T> &s, T *t)

append(const boost_132::shared_ptr<const void> &t)

inline shared_ptr_helper()

inline ~shared_ptr_helper()

Private Types

typedef std::set<boost::shared_ptr<const void>, collection_type_compare> collection_type

typedef collection_type::const_iterator iterator_type

Private Functions

get_od(const void *od, const icecube::serialization::extended_type_info *true_type, const icecube::serialization::extended_type_info *this_type)

append(const boost::shared_ptr<const void>&)

Private Members

collection_type *m_pointers

std::list<boost_132::shared_ptr<const void>> *m_pointers_132

template<template<class T> class SPT>
class shared_ptr_helper

#include <shared_ptr_helper.hpp>

Public Functions

template<class T>
inline void reset(SPT<T> &s, T *t)

inline shared_ptr_helper()

inline virtual ~shared_ptr_helper()

Private Types

typedef std::map<const void*, SPT<const void>> object_shared_pointer_map

Private Members

object_shared_pointer_map *m_o_sp

Friends

template<class Archive, class U>
friend void load(Archive &ar, SPT<U> &t, const unsigned int file_version)

template<class T>
struct shared_ptr_traits

#include <shared_ptr_132.hpp>

Public Types

typedef T &reference

template<>
struct shared_ptr_traits<void>

#include <shared_ptr_132.hpp>

Public Types

typedef void reference

template<>
struct shared_ptr_traits<void const>

#include <shared_ptr_132.hpp>

Public Types

typedef void reference

template<>
struct shared_ptr_traits<void volatile const>

#include <shared_ptr_132.hpp>

Public Types

typedef void reference

template<>
struct shared_ptr_traits<void volatile>

#include <shared_ptr_132.hpp>

Public Types

typedef void reference

template<class T>
class singleton : public icecube::serialization::singleton_module

#include <singleton.hpp>

Public Static Functions

static inline I3_DLLEXPORT T & get_mutable_instance ()

static inline I3_DLLEXPORT const T & get_const_instance ()

static inline I3_DLLEXPORT bool is_destroyed ()

Private Static Functions

static inline void use(T const&)

static inline I3_DLLEXPORT T & get_instance ()

Private Static Attributes

static I3_DLLEXPORT T & instance   = singleton< T >::get_instance()

class singleton_module : public noncopyable

#include <singleton.hpp>

Subclassed by icecube::serialization::singleton< T >, icecube::serialization::singleton< extended_type_info_no_rtti< T > >, icecube::serialization::singleton< extended_type_info_typeid< T > >

Public Static Functions

static inline void lock()

static inline void unlock()

static inline bool is_locked()

Private Static Functions

static inline bool &get_lock()

template<class T>
class singleton_wrapper : public T

#include <singleton.hpp>

Public Functions

inline ~singleton_wrapper()

Public Static Attributes

static bool m_is_destroyed = false

class sp_counted_base

#include <shared_count_132.hpp>

Subclassed by boost_132::detail::sp_counted_base_impl< P, D >

Public Functions

inline sp_counted_base()

inline virtual ~sp_counted_base()

virtual void dispose() = 0

inline virtual void destruct()

virtual void *get_deleter(std::type_info const &ti) = 0

inline void add_ref_copy()

inline void add_ref_lock()

inline void release()

inline void weak_add_ref()

inline void weak_release()

inline long use_count() const

sp_counted_base(sp_counted_base const&)

sp_counted_base &operator=(sp_counted_base const&)

Public Members

long use_count_

long weak_count_

Private Types

typedef boost::detail::lightweight_mutex mutex_type

template<class P, class D>
class sp_counted_base_impl : public boost_132::detail::sp_counted_base

#include <shared_count_132.hpp>

Public Types

typedef sp_counted_base_impl<P, D> this_type

Public Functions

sp_counted_base_impl(sp_counted_base_impl const&)

sp_counted_base_impl &operator=(sp_counted_base_impl const&)

inline sp_counted_base_impl(P p, D d)

inline virtual void dispose()

inline virtual void *get_deleter(std::type_info const &ti)

Public Members

P ptr

D del

template<typename T>
struct stack_allocate

#include <stack_constructor.hpp>

Subclassed by icecube::serialization::detail::stack_construct< Archive, T >

Public Functions

inline T *address()

inline T &reference()

Private Types

typedef boost::aligned_storage<sizeof(T), boost::alignment_of<T>::value> type

Private Members

type storage_

template<class Archive, class T>
struct stack_construct : public icecube::serialization::detail::stack_allocate<T>

#include <stack_constructor.hpp>

Public Functions

inline stack_construct(Archive &ar, const unsigned int version)

inline ~stack_construct()

template<typename U, typename C>
struct stack_load : public STD::stack<U, C>

#include <stack.hpp>

Public Functions

template<class Archive>
inline void operator()(Archive &ar, const unsigned int file_version)

template<typename U, typename C>
struct stack_save : public STD::stack<U, C>

#include <stack.hpp>

Public Functions

template<class Archive>
inline void operator()(Archive &ar, const unsigned int file_version) const

template<class T>
class state_saver : private noncopyable

#include <state_saver.hpp>

Public Functions

inline state_saver(T &object)

inline ~state_saver()

Private Members

const T previous_value

T &previous_ref

struct static_cast_tag

#include <shared_ptr_132.hpp>

template<bool B, int L>
struct static_warning_test

#include <static_warning.hpp>

Public Members

boost::mpl::eval_if_c<B, boost::mpl::true_, typename boost::mpl::identity<boost::mpl::print<I3_SERIALIZATION_STATIC_WARNING_LINE<L>>>>::type type

class text_iarchive : public icecube::archive::text_iarchive_impl<text_iarchive>

#include <text_iarchive.hpp>

Subclassed by icecube::archive::detail::polymorphic_iarchive_route< text_iarchive >

Public Functions

inline text_iarchive(std::istream &is_, unsigned int flags = 0)

inline ~text_iarchive()

template<class Archive>
class text_iarchive_impl : public icecube::archive::basic_text_iprimitive<std::istream>, public icecube::archive::basic_text_iarchive<Archive>

#include <text_iarchive.hpp>

Protected Functions

template<class T>
inline void load(T &t)

inline void load(version_type &t)

inline void load(icecube::serialization::item_version_type &t)

load(char *t)

load(wchar_t *t)

load(std::string &s)

load(std::wstring &ws)

template<class T>
inline void load_override(T &t, I3_PFTO int)

load_override(class_name_type &t, int)

init()

text_iarchive_impl(std::istream &is, unsigned int flags)

inline ~text_iarchive_impl()

Friends

friend class detail::interface_iarchive< Archive >

friend class load_access

class text_oarchive : public icecube::archive::text_oarchive_impl<text_oarchive>

#include <text_oarchive.hpp>

Public Functions

inline text_oarchive(std::ostream &os_, unsigned int flags = 0)

inline ~text_oarchive()

template<class Archive>
class text_oarchive_impl : public icecube::archive::basic_text_oprimitive<std::ostream>, public icecube::archive::basic_text_oarchive<Archive>

#include <text_oarchive.hpp>

Public Functions

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

Protected Functions

template<class T>
inline void save(const T &t)

inline void save(const version_type &t)

inline void save(const icecube::serialization::item_version_type &t)

save(const char *t)

save(const wchar_t *t)

save(const std::string &s)

save(const std::wstring &ws)

text_oarchive_impl(std::ostream &os, unsigned int flags)

inline ~text_oarchive_impl()

Friends

friend class detail::interface_oarchive< Archive >

friend class basic_text_oarchive< Archive >

friend class save_access

class text_wiarchive : public icecube::archive::text_wiarchive_impl<text_wiarchive>

#include <text_wiarchive.hpp>

Subclassed by icecube::archive::detail::polymorphic_iarchive_route< text_wiarchive >

Public Functions

inline text_wiarchive(std::wistream &is, unsigned int flags = 0)

inline ~text_wiarchive()

template<class Archive>
class text_wiarchive_impl : public icecube::archive::basic_text_iprimitive<std::wistream>, public icecube::archive::basic_text_iarchive<Archive>

#include <text_wiarchive.hpp>

Protected Functions

template<class T>
inline void load(T &t)

inline void load(version_type &t)

inline void load(icecube::serialization::item_version_type &t)

load(char *t)

load(wchar_t *t)

load(std::string &s)

load(std::wstring &ws)

template<class T>
inline void load_override(T &t, I3_PFTO int)

text_wiarchive_impl(std::wistream &is, unsigned int flags)

inline ~text_wiarchive_impl()

Friends

friend class detail::interface_iarchive< Archive >

friend class load_access

class text_woarchive : public icecube::archive::text_woarchive_impl<text_woarchive>

#include <text_woarchive.hpp>

Public Functions

inline text_woarchive(std::wostream &os, unsigned int flags = 0)

inline ~text_woarchive()

template<class Archive>
class text_woarchive_impl : public icecube::archive::basic_text_oprimitive<std::wostream>, public icecube::archive::basic_text_oarchive<Archive>

#include <text_woarchive.hpp>

Public Functions

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

Protected Functions

template<class T>
inline void save(const T &t)

inline void save(const version_type &t)

inline void save(const icecube::serialization::item_version_type &t)

save(const char *t)

save(const wchar_t *t)

save(const std::string &s)

save(const std::wstring &ws)

inline text_woarchive_impl(std::wostream &os, unsigned int flags)

Friends

friend class detail::interface_oarchive< Archive >

friend class basic_text_oarchive< Archive >

friend class save_access

template<class CharType>
struct to_6_bit

#include <binary_from_base64.hpp>

Public Types

typedef CharType result_type

Public Functions

inline CharType operator()(CharType t) const

template<class T>
struct tracking_level : public icecube::serialization::tracking_level_impl<const T>

#include <tracking.hpp>

template<class T>
struct tracking_level<::std::shared_ptr<T>>

#include <shared_ptr.hpp>

Public Types

typedef boost::mpl::integral_c_tag tag

typedef boost::mpl::int_<::icecube::serialization::track_never> type

template<class T>
struct tracking_level<nvp<T>>

#include <nvp.hpp>

Public Types

typedef boost::mpl::integral_c_tag tag

typedef boost::mpl::int_<track_never> type

template<std::size_t size>
struct tracking_level<std::bitset<size>> : public boost::mpl::int_<track_never>

#include <bitset.hpp>

template<class T>
struct tracking_level<std::complex<T>> : public boost::mpl::int_<track_never>

#include <complex.hpp>

template<class T>
struct tracking_level_impl

#include <tracking.hpp>

Public Types

typedef boost::mpl::integral_c_tag tag

typedef boost::mpl::eval_if<boost::is_base_and_derived<icecube::serialization::basic_traits, T>, traits_class_tracking<T>, typename boost::mpl::eval_if<boost::is_pointer<T>, boost::mpl::int_<track_never>, typename boost::mpl::eval_if<typename boost::mpl::equal_to<implementation_level<T>, boost::mpl::int_<primitive_type>>, boost::mpl::int_<track_never>, boost::mpl::int_<track_selectively>>>>::type type

struct tracking_type

#include <basic_archive.hpp>

Public Functions

inline explicit tracking_type(const bool t_ = false)

inline tracking_type(const tracking_type &t_)

inline operator bool() const

inline operator bool&()

inline tracking_type &operator=(const bool t_)

inline bool operator==(const tracking_type &rhs) const

inline bool operator==(const bool &rhs) const

inline tracking_type &operator=(const tracking_type &rhs)

Public Members

bool t

template<class T, int Level, int Tracking, unsigned int Version = 0, class ETII = extended_type_info_impl<T>, class Wrapper = boost::mpl::false_>
struct traits : public icecube::serialization::basic_traits

#include <traits.hpp>

Public Types

typedef boost::mpl::int_<Level> level

typedef boost::mpl::int_<Tracking> tracking

typedef boost::mpl::int_<Version> version

typedef ETII type_info_implementation

typedef Wrapper is_wrapper

template<class U>
struct traits_class_level

#include <level.hpp>

Public Types

typedef U::level type

template<class U>
struct traits_class_tracking

#include <tracking.hpp>

Public Types

typedef U::tracking type

template<class U>
struct traits_class_typeinfo_implementation

#include <type_info_implementation.hpp>

Public Types

typedef U::type_info_implementation::type type

template<class U>
struct traits_class_version

#include <version.hpp>

Public Types

typedef U::version type

template<class Base, int BitsOut, int BitsIn, class CharType = typename boost::iterator_value<Base>::type>
class transform_width : public boost::iterator_adaptor<transform_width<Base, BitsOut, BitsIn, CharType>, Base, CharType, boost::single_pass_traversal_tag, CharType>

#include <transform_width.hpp>

Public Functions

template<class T> inline  transform_width (I3_PFTO_WRAPPER(T) start)

inline transform_width(const transform_width &rhs)

Private Types

typedef boost::iterator_adaptor<transform_width<Base, BitsOut, BitsIn, CharType>, Base, CharType, boost::single_pass_traversal_tag, CharType> super_t

typedef transform_width<Base, BitsOut, BitsIn, CharType> this_t

typedef boost::iterator_value<Base>::type base_value_type

Private Functions

void fill()

inline CharType dereference() const

inline bool equal_impl(const this_t &rhs)

inline bool equal(const this_t &rhs) const

inline void increment()

Private Members

bool m_buffer_out_full

CharType m_buffer_out

base_value_type m_buffer_in

unsigned int m_remaining_bits

bool m_end_of_sequence

struct tri_state

#include <dataflow.hpp>

Public Types

enum state_enum

Values:

enumerator is_false

enumerator is_true

enumerator is_indeterminant

Public Functions

inline operator bool()

inline tri_state &operator=(bool rhs)

inline tri_state(bool rhs)

inline tri_state(state_enum state)

inline bool operator==(const tri_state &rhs) const

inline bool operator!=(const tri_state &rhs) const

Public Members

enum icecube::archive::iterators::tri_state::state_enum m_state

struct type_compare

Public Functions

inline bool operator()(const extended_type_info_typeid_0 *lhs, const extended_type_info_typeid_0 *rhs) const

template<class T>
struct type_info_implementation

#include <type_info_implementation.hpp>

Public Types

typedef boost::mpl::eval_if<boost::is_base_and_derived<serialization::basic_traits, T>, traits_class_typeinfo_implementation<T>, boost::mpl::identity<typename extended_type_info_impl<T>::type>>::type type

struct undefined

#include <extended_type_info_no_rtti.hpp>

Public Static Functions

static const char *invoke()

template<class Derived, class Base>
class unescape : public boost::iterator_adaptor<unescape<Derived, Base>, Base, boost::pointee<Base>::type, boost::single_pass_traversal_tag, boost::pointee<Base>::type>

#include <unescape.hpp>

Public Types

typedef this_t::value_type value_type

typedef this_t::reference reference

Public Functions

inline unescape(Base base)

Private Types

typedef boost::iterator_adaptor<unescape<Derived, Base>, Base, typename boost::pointee<Base>::type, boost::single_pass_traversal_tag, typename boost::pointee<Base>::type> super_t

typedef unescape<Derived, Base> this_t

Private Functions

inline value_type dereference_impl()

inline reference dereference() const

inline void increment()

Private Members

value_type m_current_value

bool m_full

template<class Archive>
struct use_array_optimization : public boost::mpl::always<boost::mpl::false_>

#include <array.hpp>

struct use_array_optimization

#include <portable_binary_archive.hpp>

struct use_array_optimization

#include <basic_binary_oprimitive.hpp>

struct use_array_optimization

#include <portable_binary_archive.hpp>

struct use_array_optimization

#include <basic_binary_iprimitive.hpp>

template<typename T>
struct variable_int

Public Functions

inline void save(portable_binary_oarchive &pba, uint64_t t)

inline void load(portable_binary_iarchive &pba, uint64_t &t)

Public Members

const T ff = std::numeric_limits<T>::max()

template<class S>
struct variant_impl

#include <variant.hpp>

Public Static Functions

template<class Archive, class V>
static inline void load(Archive &ar, int which, V &v, const unsigned int version)

template<class Archive>
struct variant_save_visitor : public boost::static_visitor<>

#include <variant.hpp>

Public Functions

inline variant_save_visitor(Archive &ar)

template<class T>
inline void operator()(T const &value) const

Private Members

Archive &m_ar

template<class T>
struct version

#include <version.hpp>

Public Types

typedef boost::mpl::integral_c_tag tag

typedef boost::mpl::eval_if<boost::is_base_and_derived<icecube::serialization::basic_traits, T>, traits_class_version<T>, boost::mpl::int_<0>>::type type

template<class T>
struct version<::std::shared_ptr<T>>

#include <shared_ptr.hpp>

Public Types

typedef boost::mpl::integral_c_tag tag

typedef boost::mpl::int_<1> type

class version_type

#include <basic_archive.hpp>

Public Functions

inline version_type()

inline explicit version_type(const unsigned int &t_)

inline version_type(const version_type &t_)

inline version_type &operator=(const version_type &rhs)

inline operator base_type() const

inline operator base_type&()

inline bool operator==(const version_type &rhs) const

inline bool operator<(const version_type &rhs) const

Private Types

typedef uint_least32_t base_type

Private Members

base_type t

template<class Derived, class Base>
class void_caster : public icecube::serialization::void_cast_detail::void_caster_primitive<Derived, Base>

#include <void_cast.hpp>

Subclassed by icecube::serialization::void_cast_detail::void_caster_argument, icecube::serialization::void_cast_detail::void_caster_base< Derived, Base >, icecube::serialization::void_cast_detail::void_caster_shortcut, icecube::serialization::void_cast_detail::void_caster_virtual_base< Derived, Base >

class void_caster_argument : public icecube::serialization::void_caster<Derived, Base>

Public Functions

inline void_caster_argument(extended_type_info const *derived, extended_type_info const *base)

inline virtual ~void_caster_argument()

Private Functions

inline virtual void const *upcast(void const*const) const

inline virtual void const *downcast(void const*const) const

inline virtual bool has_virtual_base() const

template<class Derived, class Base>
struct void_caster_base : public icecube::serialization::void_caster<Derived, Base>

#include <void_cast.hpp>

Public Types

typedef void_cast_detail::void_caster_primitive<Derived, Base> type

struct void_caster_compare

Public Functions

inline bool operator()(const void_caster *lhs, const void_caster *rhs) const

template<class Derived, class Base>
class void_caster_primitive

#include <void_cast.hpp>

Subclassed by icecube::serialization::void_caster< Derived, Base >

Public Functions

void_caster_primitive()

virtual ~void_caster_primitive()

Private Functions

inline virtual void const *downcast(void const *const t) const

inline virtual void const *upcast(void const *const t) const

inline virtual bool has_virtual_base() const

Private Static Functions

static inline std::ptrdiff_t base_offset()

class void_caster_shortcut : public icecube::serialization::void_caster<Derived, Base>

Public Functions

inline void_caster_shortcut(extended_type_info const *derived, extended_type_info const *base, std::ptrdiff_t difference, bool includes_virtual_base, void_caster const *const parent)

inline virtual ~void_caster_shortcut()

Private Functions

void const *vbc_upcast(void const *const t) const

void const *vbc_downcast(void const *const t) const

inline virtual void const *upcast(void const *const t) const

inline virtual void const *downcast(void const *const t) const

inline virtual bool is_shortcut() const

inline virtual bool has_virtual_base() const

Private Members

bool m_includes_virtual_base

template<class Derived, class Base>
class void_caster_virtual_base : public icecube::serialization::void_caster<Derived, Base>

#include <void_cast.hpp>

Public Functions

inline virtual void const *downcast(void const *const t) const

inline virtual void const *upcast(void const *const t) const

void_caster_virtual_base()

virtual ~void_caster_virtual_base()

Private Functions

inline virtual bool has_virtual_base() const

struct void_deleter

Public Functions

inline void_deleter(const icecube::serialization::extended_type_info *eti)

inline void operator()(void *vp) const

Public Members

const icecube::serialization::extended_type_info *m_eti

template<class TPtr>
struct void_pointer

#include <smart_cast.hpp>

Public Static Functions

template<class UPtr>
static inline TPtr cast(UPtr uptr)

template<class Base>
class wchar_from_mb : public boost::iterator_adaptor<wchar_from_mb<Base>, Base, wchar_t, boost::single_pass_traversal_tag, wchar_t>

#include <wchar_from_mb.hpp>

Public Functions

template<class T> inline  wchar_from_mb (I3_PFTO_WRAPPER(T) start)

inline wchar_from_mb(const wchar_from_mb &rhs)

Private Types

typedef boost::iterator_adaptor<wchar_from_mb<Base>, Base, wchar_t, boost::single_pass_traversal_tag, wchar_t> super_t

typedef wchar_from_mb<Base> this_t

Private Functions

wchar_t drain()

inline wchar_t dereference_impl()

inline wchar_t dereference() const

inline void increment()

Private Members

wchar_t m_current_value

bool m_full

class weak_count

#include <shared_count_132.hpp>

Public Functions

inline weak_count()

inline weak_count(shared_count const &r)

inline weak_count(weak_count const &r)

inline ~weak_count()

inline weak_count &operator=(shared_count const &r)

inline weak_count &operator=(weak_count const &r)

inline void swap(weak_count &r)

inline long use_count() const

Private Members

sp_counted_base *pi_

Friends

friend class shared_count

inline friend bool operator==(weak_count const &a, weak_count const &b)

inline friend bool operator<(weak_count const &a, weak_count const &b)

template<class T>
class weak_ptr

#include <shared_ptr_132.hpp>

template<class T, int Level = object_serializable, int Tracking = track_never, unsigned int Version = 0, class ETII = extended_type_info_impl<T>>
struct wrapper_traits : public icecube::serialization::traits<T, Level, Tracking, Version, ETII, boost::mpl::true_>

#include <wrapper.hpp>

the base class for serialization wrappers

wrappers need to be treated differently at various places in the serialization library, e.g. saving of non-const wrappers has to be possible. Since partial specialization

template<class Base>
class xml_escape : public icecube::archive::iterators::escape<xml_escape<Base>, Base>

#include <xml_escape.hpp>

Public Functions

char fill(const char *&bstart, const char *&bend)

wchar_t fill(const wchar_t *&bstart, const wchar_t *&bend)

template<class T> inline  xml_escape (I3_PFTO_WRAPPER(T) start)

inline xml_escape(const xml_escape &rhs)

Private Types

typedef escape<xml_escape<Base>, Base> super_t

class xml_iarchive : public icecube::archive::xml_iarchive_impl<xml_iarchive>

#include <xml_iarchive.hpp>

Subclassed by icecube::archive::detail::polymorphic_iarchive_route< xml_iarchive >

Public Functions

inline xml_iarchive(std::istream &is, unsigned int flags = 0)

inline ~xml_iarchive()

template<class Archive>
class xml_iarchive_impl : public icecube::archive::basic_text_iprimitive<std::istream>, public icecube::archive::basic_xml_iarchive<Archive>

#include <xml_iarchive.hpp>

Protected Functions

inline std::istream &get_is()

template<class T>
inline void load(T &t)

inline void load(version_type &t)

inline void load(icecube::serialization::item_version_type &t)

load(char *t)

load(wchar_t *t)

load(std::string &s)

load(std::wstring &ws)

template<class T>
inline void load_override(T &t, I3_PFTO int)

load_override(class_name_type &t, int)

init()

xml_iarchive_impl(std::istream &is, unsigned int flags)

~xml_iarchive_impl()

Protected Attributes

xml_grammar *gimpl

Friends

friend class detail::interface_iarchive< Archive >

friend class basic_xml_iarchive< Archive >

friend class load_access

class xml_oarchive : public icecube::archive::xml_oarchive_impl<xml_oarchive>

#include <xml_oarchive.hpp>

Public Functions

inline xml_oarchive(std::ostream &os, unsigned int flags = 0)

inline ~xml_oarchive()

template<class Archive>
class xml_oarchive_impl : public icecube::archive::basic_text_oprimitive<std::ostream>, public icecube::archive::basic_xml_oarchive<Archive>

#include <xml_oarchive.hpp>

Public Functions

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

Protected Functions

template<class T>
inline void save(const T &t)

inline void save(const version_type &t)

inline void save(const icecube::serialization::item_version_type &t)

save(const char *t)

save(const wchar_t *t)

save(const std::string &s)

save(const std::wstring &ws)

xml_oarchive_impl(std::ostream &os, unsigned int flags)

inline ~xml_oarchive_impl()

Friends

friend class detail::interface_oarchive< Archive >

friend class basic_xml_oarchive< Archive >

friend class save_access

template<class Base>
class xml_unescape : public icecube::archive::iterators::unescape<xml_unescape<Base>, Base>

#include <xml_unescape.hpp>

Public Types

typedef this_t::value_type value_type

Public Functions

void drain_residue(const char *literal)

value_type drain()

template<class T> inline  xml_unescape (I3_PFTO_WRAPPER(T) start)

inline xml_unescape(const xml_unescape &rhs)

Private Types

typedef xml_unescape<Base> this_t

typedef unescape<this_t, Base> super_t

typedef boost::iterator_reference<this_t> reference_type

Private Functions

inline reference_type dereference() const

class xml_unescape_exception : public std::exception

#include <xml_unescape_exception.hpp>

Public Functions

inline xml_unescape_exception()

inline virtual const char *what() const

class xml_wiarchive : public icecube::archive::xml_wiarchive_impl<xml_wiarchive>

#include <xml_wiarchive.hpp>

Subclassed by icecube::archive::detail::polymorphic_iarchive_route< xml_wiarchive >

Public Functions

inline xml_wiarchive(std::wistream &is, unsigned int flags = 0)

inline ~xml_wiarchive()

template<class Archive>
class xml_wiarchive_impl : public icecube::archive::basic_text_iprimitive<std::wistream>, public icecube::archive::basic_xml_iarchive<Archive>

#include <xml_wiarchive.hpp>

Protected Functions

inline std::wistream &get_is()

template<class T>
inline void load(T &t)

inline void load(version_type &t)

inline void load(icecube::serialization::item_version_type &t)

load(char *t)

load(wchar_t *t)

load(std::string &s)

load(std::wstring &ws)

template<class T>
inline void load_override(T &t, I3_PFTO int)

load_override(class_name_type &t, int)

init()

xml_wiarchive_impl(std::wistream &is, unsigned int flags)

~xml_wiarchive_impl()

Protected Attributes

xml_wgrammar *gimpl

Friends

friend class detail::interface_iarchive< Archive >

friend class basic_xml_iarchive< Archive >

friend class load_access

class xml_woarchive : public icecube::archive::xml_woarchive_impl<xml_woarchive>

#include <xml_woarchive.hpp>

Public Functions

inline xml_woarchive(std::wostream &os, unsigned int flags = 0)

inline ~xml_woarchive()

template<class Archive>
class xml_woarchive_impl : public icecube::archive::basic_text_oprimitive<std::wostream>, public icecube::archive::basic_xml_oarchive<Archive>

#include <xml_woarchive.hpp>

Public Functions

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

Protected Functions

template<class T>
inline void save(const T &t)

inline void save(const version_type &t)

inline void save(const icecube::serialization::item_version_type &t)

save(const char *t)

save(const wchar_t *t)

save(const std::string &s)

save(const std::wstring &ws)

xml_woarchive_impl(std::wostream &os, unsigned int flags)

inline ~xml_woarchive_impl()

Friends

friend class detail::interface_oarchive< Archive >

friend class basic_xml_oarchive< Archive >

friend class save_access

namespace [anonymous]

namespace boost_132

Functions

template<class T, class U>
inline bool operator==(shared_ptr<T> const &a, shared_ptr<U> const &b)

template<class T, class U>
inline bool operator!=(shared_ptr<T> const &a, shared_ptr<U> const &b)

template<class T, class U>
inline bool operator<(shared_ptr<T> const &a, shared_ptr<U> const &b)

template<class T>
inline void swap(shared_ptr<T> &a, shared_ptr<T> &b)

template<class T, class U>
shared_ptr<T> static_pointer_cast(shared_ptr<U> const &r)

template<class T, class U>
shared_ptr<T> const_pointer_cast(shared_ptr<U> const &r)

template<class T, class U>
shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const &r)

template<class T, class U>
shared_ptr<T> shared_static_cast(shared_ptr<U> const &r)

template<class T, class U>
shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const &r)

template<class T, class U>
shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const &r)

template<class T, class U>
shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const &r)

template<class T>
inline T *get_pointer(shared_ptr<T> const &p)

template<class E, class T, class Y>
std::basic_ostream<E, T> &operator<<(std::basic_ostream<E, T> &os, shared_ptr<Y> const &p)

template<class D, class T>
D *get_deleter(shared_ptr<T> const &p)

namespace detail

Functions

template<class T, class Y>
void sp_enable_shared_from_this(shared_count const &pn, enable_shared_from_this<T> const *pe, Y const *px)

inline void sp_enable_shared_from_this(shared_count const&, ...)

namespace serialization

namespace detail

namespace icecube

namespace archive

Typedefs

typedef basic_xml_grammar<char> xml_grammar

typedef basic_xml_grammar<wchar_t> xml_wgrammar

typedef detail::polymorphic_oarchive_route<binary_oarchive_impl<binary_oarchive, std::ostream::char_type, std::ostream::traits_type>> polymorphic_binary_oarchive

typedef detail::polymorphic_oarchive_route<text_oarchive_impl<text_oarchive>> polymorphic_text_oarchive

typedef detail::polymorphic_oarchive_route<text_woarchive_impl<text_woarchive>> polymorphic_text_woarchive

typedef detail::polymorphic_oarchive_route<xml_oarchive_impl<xml_oarchive>> polymorphic_xml_oarchive

typedef detail::polymorphic_oarchive_route<xml_woarchive_impl<xml_woarchive>> polymorphic_xml_woarchive

Enums

enum exception_code

Values:

enumerator no_exception

enumerator other_exception

enumerator unregistered_class

enumerator invalid_signature

enumerator unsupported_version

enumerator pointer_conflict

enumerator incompatible_native_format

enumerator array_size_too_short

enumerator input_stream_error

enumerator invalid_class_name

enumerator unregistered_cast

enumerator unsupported_class_version

enumerator multiple_code_instantiation

enumerator output_stream_error

enum archive_flags

Values:

enumerator no_header

enumerator no_codecvt

enumerator no_xml_tag_checking

enumerator no_tracking

enumerator flags_last

Functions

I3_ARCHIVE_SIGNATURE()

I3_ARCHIVE_VERSION()

I3_ARCHIVE_XML_OBJECT_ID()

I3_ARCHIVE_XML_OBJECT_REFERENCE()

I3_ARCHIVE_XML_CLASS_ID()

I3_ARCHIVE_XML_CLASS_ID_REFERENCE()

I3_ARCHIVE_XML_CLASS_NAME()

I3_ARCHIVE_XML_TRACKING()

I3_ARCHIVE_XML_VERSION()

I3_ARCHIVE_XML_SIGNATURE()

template<class Facet>
inline std::locale *add_facet(const std::locale &l, Facet *f)

archive_exception(exception_code c, const char *e1 = NULL, const char *e2 = NULL) noexcept

archive_exception(archive_exception const&) noexcept

virtual  ~archive_exception () noexceptoverride

virtual const char * what () const noexceptoverride

unsigned int append(unsigned int l, const char *a)

archive_exception()

template<class Archive, class T>
inline void load(Archive &ar, T &t)

template<class Archive, class T>
inline void save(Archive &ar, T &t)

inline const char *tmpdir()

class I3_ARCHIVE_DECL(BOOST_PP_EMPTY()) xml_archive_exception xml_archive_exception (exception_code c, const char *e1=NULL, const char *e2=NULL)

Variables

exception_code code

namespace detail

Typedefs

typedef std::set<const basic_serializer*, type_info_pointer_compare> map_type

Functions

template<class Archive> class I3_ARCHIVE_OR_WARCHIVE_DECL (BOOST_PP_EMPTY()) archive_serializer_map

class I3_ARCHIVE_DECL (BOOST_PP_EMPTY()) basic_archive_impl

virtual void vload(version_type &t) = 0

virtual void vload(object_id_type &t) = 0

virtual void vload(class_id_type &t) = 0

virtual void vload(class_id_optional_type &t) = 0

virtual void vload(class_name_type &t) = 0

virtual void vload(tracking_type &t) = 0

basic_iarchive(unsigned int flags)

~basic_iarchive()

void next_object_pointer(void *t)

void register_basic_serializer(const basic_iserializer &bis)

void load_object(void *t, const basic_iserializer &bis)

const basic_pointer_iserializer *load_pointer(void *&t, const basic_pointer_iserializer *bpis_ptr, const basic_pointer_iserializer *(*finder)(const icecube::serialization::extended_type_info &eti))

void set_library_version(library_version_type archive_library_version)

library_version_type get_library_version() const

unsigned int get_flags() const

void reset_object_address(const void *new_address, const void *old_address)

void delete_created_pointers()

explicit basic_iserializer(const icecube::serialization::extended_type_info &type)

~basic_iserializer()

bool serialized_as_pointer() const

void set_bpis(basic_pointer_iserializer *bpis)

const basic_pointer_iserializer *get_bpis_ptr() const

virtual void load_object_data(basic_iarchive &ar, void *x, const unsigned int file_version) const = 0

virtual bool class_info() const = 0

virtual bool tracking(const unsigned int) const = 0

virtual version_type version() const = 0

virtual bool is_polymorphic() const = 0

virtual void destroy(void *address) const = 0

virtual void vsave(const version_type t) = 0

virtual void vsave(const object_id_type t) = 0

virtual void vsave(const object_reference_type t) = 0

virtual void vsave(const class_id_type t) = 0

virtual void vsave(const class_id_optional_type t) = 0

virtual void vsave(const class_id_reference_type t) = 0

virtual void vsave(const class_name_type &t) = 0

virtual void vsave(const tracking_type t) = 0

basic_oarchive(unsigned int flags = 0)

~basic_oarchive()

void register_basic_serializer(const basic_oserializer &bos)

void save_object(const void *x, const basic_oserializer &bos)

void save_pointer(const void *t, const basic_pointer_oserializer *bpos_ptr)

void save_null_pointer()

void end_preamble()

explicit basic_oserializer(const icecube::serialization::extended_type_info &type_)

~basic_oserializer()

void set_bpos(basic_pointer_oserializer *bpos)

const basic_pointer_oserializer *get_bpos() const

virtual void save_object_data(basic_oarchive &ar, const void *x) const = 0

class I3_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer ~basic_pointer_iserializer ()

virtual void *heap_allocation() const = 0

virtual const basic_iserializer &get_basic_serializer() const = 0

virtual void load_object_ptr(basic_iarchive &ar, void *x, const unsigned int file_version) const = 0

~basic_pointer_oserializer()

virtual void save_object_ptr(basic_oarchive &ar, const void *x) const = 0

bool insert(const basic_serializer *bs)

void erase(const basic_serializer *bs)

const basic_serializer *find(const icecube::serialization::extended_type_info &type_) const

basic_serializer_map &operator=(basic_serializer_map const&)

template<class T>
inline void check_object_level()

template<class T>
inline void check_object_versioning()

template<class T>
inline void check_object_tracking()

template<class T>
inline void check_pointer_level()

template<class T>
inline void check_pointer_tracking()

template<class T>
inline void check_const_loading()

template<class Serializable>
void instantiate_ptr_serialization(Serializable*, int, adl_tag)

Variables

class I3_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive basic_iarchive_impl * pimpl

map_type m_map

namespace extra_detail

namespace iterators

namespace detail

namespace portable

Functions

template<typename T>
inline void swap(T &t)

namespace serialization

Enums

enum level_type

Values:

enumerator not_serializable

enumerator primitive_type

enumerator object_serializable

enumerator object_class_info

enum tracking_type

Values:

enumerator track_never

enumerator track_selectively

enumerator track_always

Functions

void_upcast(extended_type_info const &derived, extended_type_info const &base, void const *const t)

void_downcast(extended_type_info const &derived, extended_type_info const &base, void const *const t)

template<class Archive, class T>
inline void serialize_adl(Archive&, T&, const unsigned int)

template<class T>
inline const array<T> make_array(T *t, std::size_t s)

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

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

template<class Base, class Derived>
detail::base_cast<Base, Derived>::type &base_object(Derived &d)

inline const binary_object make_binary_object(void *t, std::size_t size)

template<class Archive, std::size_t size>
inline void save(Archive &ar, std::bitset<size> const &t, const unsigned int)

template<class Archive, std::size_t size>
inline void load(Archive &ar, std::bitset<size> &t, const unsigned int)

template<class Archive, std::size_t size>
inline void serialize(Archive &ar, std::bitset<size> &t, const unsigned int version)

template<class Archive, class T>
inline void serialize(Archive &ar, std::complex<T> &t, const unsigned int file_version)

template<class Archive, class T>
inline void save(Archive &ar, std::complex<T> const &t, const unsigned int)

template<class Archive, class T>
inline void load(Archive &ar, std::complex<T> &t, const unsigned int)

template<class Archive, class U, class Allocator>
inline void save(Archive &ar, const std::deque<U, Allocator> &t, const unsigned int)

template<class Archive, class U, class Allocator>
inline void load(Archive &ar, std::deque<U, Allocator> &t, const unsigned int)

template<class Archive, class U, class Allocator>
inline void serialize(Archive &ar, std::deque<U, Allocator> &t, const unsigned int file_version)

template<class Archive>
inline void save(Archive &ar, boost::dynamic_bitset<> const &t, const unsigned int)

template<class Archive>
inline void load(Archive &ar, boost::dynamic_bitset<> &t, const unsigned int)

template<class Archive>
inline void serialize(Archive &ar, boost::dynamic_bitset<> &t, const unsigned int version)

template<class T>
inline const ephemeral_object<T> ephemeral(const char *name, T &t)

virtual bool is_less_than(const extended_type_info&) const = 0

virtual bool is_equal(const extended_type_info&) const = 0

void key_unregister() const

void key_register() const

extended_type_info(const unsigned int type_info_key, const char *key)

~extended_type_info()

const char *get_key() const

virtual const char *get_debug_info() const = 0

bool operator<(const extended_type_info &rhs) const

bool operator==(const extended_type_info &rhs) const

bool operator!=(const extended_type_info &rhs) const

static const extended_type_info *find(const char *key)

virtual void *construct(unsigned int = 0, ...) const = 0

virtual void destroy(void const*const) const = 0

template<class T>
inline const char *guid()

template<class T, int N>
T *factory(std::va_list)

template<class Archive, class U, class Allocator>
inline void save(Archive &ar, const std::forward_list<U, Allocator> &t, const unsigned int file_version)

template<class Archive, class U, class Allocator>
inline void load(Archive &ar, std::forward_list<U, Allocator> &t, const unsigned int file_version)

template<class Archive, class U, class Allocator>
inline void serialize(Archive &ar, std::forward_list<U, Allocator> &t, const unsigned int file_version)

template<class T, int L>
inline bool operator>=(implementation_level<T> t, enum level_type l)

template<class Archive, class U, class Allocator>
inline void save(Archive &ar, const std::list<U, Allocator> &t, const unsigned int)

template<class Archive, class U, class Allocator>
inline void load(Archive &ar, std::list<U, Allocator> &t, const unsigned int)

template<class Archive, class U, class Allocator>
inline void serialize(Archive &ar, std::list<U, Allocator> &t, const unsigned int file_version)

template<class Archive, class Type, class Key, class Compare, class Allocator>
inline void save(Archive &ar, const std::map<Key, Type, Compare, Allocator> &t, const unsigned int)

template<class Archive, class Type, class Key, class Compare, class Allocator>
inline void load(Archive &ar, std::map<Key, Type, Compare, Allocator> &t, const unsigned int)

template<class Archive, class Type, class Key, class Compare, class Allocator>
inline void serialize(Archive &ar, std::map<Key, Type, Compare, Allocator> &t, const unsigned int file_version)

template<class Archive, class Type, class Key, class Compare, class Allocator>
inline void save(Archive &ar, const std::multimap<Key, Type, Compare, Allocator> &t, const unsigned int)

template<class Archive, class Type, class Key, class Compare, class Allocator>
inline void load(Archive &ar, std::multimap<Key, Type, Compare, Allocator> &t, const unsigned int)

template<class Archive, class Type, class Key, class Compare, class Allocator>
inline void serialize(Archive &ar, std::multimap<Key, Type, Compare, Allocator> &t, const unsigned int file_version)

template<class T>
inline const nvp<T> make_nvp(const char *name, T &t)

template<class Archive, class T>
void save(Archive &ar, const boost::optional<T> &t, const unsigned int)

template<class Archive, class T>
void load(Archive &ar, boost::optional<T> &t, const unsigned int)

template<class Archive, class T>
void serialize(Archive &ar, boost::optional<T> &t, const unsigned int version)

template<class T>
pfto_wrapper<T> make_pfto_wrapper(const T &t, I3_PFTO int)

template<class T>
pfto_wrapper<T> make_pfto_wrapper(const pfto_wrapper<T> &t, int)

template<class Archive, class T, class Container, class Compare>
inline void serialize(Archive &ar, std::priority_queue<T, Container, Compare> &t, const unsigned int file_version)

template<class Archive, class T, class C>
inline void serialize(Archive &ar, std::queue<T, C> &t, const unsigned int file_version)

template<class Archive, class T>
void save(Archive &ar, const boost::scoped_ptr<T> &t, const unsigned int)

template<class Archive, class T>
void load(Archive &ar, boost::scoped_ptr<T> &t, const unsigned int)

template<class Archive, class T>
void serialize(Archive &ar, boost::scoped_ptr<T> &t, const unsigned int version)

template<class Archive, class T> inline void serialize (Archive &ar, T &t, const I3_PFTO unsigned int file_version)

template<class Archive, class T> inline void save_construct_data (Archive &, const T *, const I3_PFTO unsigned int)

template<class Archive, class T> inline void load_construct_data (Archive &, T *t, const I3_PFTO unsigned int)

template<class Archive, class T>
inline void save_construct_data_adl(Archive &ar, const T *t, const unsigned int file_version)

template<class Archive, class T>
inline void load_construct_data_adl(Archive &ar, T *t, const unsigned int file_version)

template<class Archive, class Key, class Compare, class Allocator>
inline void save(Archive &ar, const std::set<Key, Compare, Allocator> &t, const unsigned int)

template<class Archive, class Key, class Compare, class Allocator>
inline void load(Archive &ar, std::set<Key, Compare, Allocator> &t, const unsigned int)

template<class Archive, class Key, class Compare, class Allocator>
inline void serialize(Archive &ar, std::set<Key, Compare, Allocator> &t, const unsigned int file_version)

template<class Archive, class Key, class Compare, class Allocator>
inline void save(Archive &ar, const std::multiset<Key, Compare, Allocator> &t, const unsigned int)

template<class Archive, class Key, class Compare, class Allocator>
inline void load(Archive &ar, std::multiset<Key, Compare, Allocator> &t, const unsigned int)

template<class Archive, class Key, class Compare, class Allocator>
inline void serialize(Archive &ar, std::multiset<Key, Compare, Allocator> &t, const unsigned int file_version)

template<class Archive, class T>
inline void save(Archive &ar, const boost::shared_ptr<T> &t, const unsigned int)

template<class Archive, class T>
inline void load(Archive &ar, boost::shared_ptr<T> &t, const unsigned int)

template<class Archive, class T>
inline void serialize(Archive &ar, boost::shared_ptr<T> &t, const unsigned int file_version)

template<class Archive, class T>
inline void save(Archive &ar, const std::shared_ptr<T> &t, const unsigned int)

template<class Archive, class T>
inline void load(Archive &ar, std::shared_ptr<T> &t, const unsigned int)

template<class Archive, class T>
inline void serialize(Archive &ar, std::shared_ptr<T> &t, const unsigned int file_version)

template<class Archive, class P, class D>
inline void serialize(Archive&, boost_132::detail::sp_counted_base_impl<P, D>&, const unsigned int)

template<class Archive, class P, class D> inline void save_construct_data (Archive &ar, const boost_132::detail::sp_counted_base_impl< P, D > *t, const I3_PFTO unsigned int)

template<class Archive, class P, class D>
inline void load_construct_data(Archive &ar, boost_132::detail::sp_counted_base_impl<P, D> *t, const unsigned int)

template<class Archive>
inline void save(Archive &ar, const boost_132::detail::shared_count &t, const unsigned int)

template<class Archive>
inline void load(Archive &ar, boost_132::detail::shared_count &t, const unsigned int)

template<class Archive, class T>
inline void save(Archive &ar, const boost_132::shared_ptr<T> &t, const unsigned int)

template<class Archive, class T>
inline void load(Archive &ar, boost_132::shared_ptr<T> &t, const unsigned int)

template<class Archive, class T>
inline void serialize(Archive &ar, boost_132::shared_ptr<T> &t, const unsigned int file_version)

template<class Archive, template<class U> class SPT>
void load(Archive &ar, SPT<class U> &t, const unsigned int file_version)

template<class T, class U>
T smart_cast(U u)

template<class T, class U>
T smart_cast_reference(U &u)

template<class Archive, class T>
inline void split_free(Archive &ar, T &t, const unsigned int file_version)

template<class Archive, class T>
inline void split_member(Archive &ar, T &t, const unsigned int file_version)

template<class Archive, class T, class C>
inline void serialize(Archive &ar, std::stack<T, C> &t, const unsigned int file_version)

template<class E>
inline void throw_exception(E const &e)

template<class T, enum tracking_type L>
inline bool operator>=(tracking_level<T> t, enum tracking_type l)

template<class Archive, class T>
inline void save(Archive &ar, const std::unique_ptr<T> &t, const unsigned int file_version)

template<class Archive, class T>
inline void load(Archive &ar, std::unique_ptr<T> &t, const unsigned int file_version)

template<class Archive, class T>
inline void serialize(Archive &ar, std::unique_ptr<T> &t, const unsigned int file_version)

template<class Archive, class Key, class HashFcn, class EqualKey, class Allocator>
inline void save(Archive &ar, const std::unordered_map<Key, HashFcn, EqualKey, Allocator> &t, const unsigned int)

template<class Archive, class Key, class HashFcn, class EqualKey, class Allocator>
inline void load(Archive &ar, std::unordered_map<Key, HashFcn, EqualKey, Allocator> &t, const unsigned int)

template<class Archive, class Key, class HashFcn, class EqualKey, class Allocator>
inline void serialize(Archive &ar, std::unordered_map<Key, HashFcn, EqualKey, Allocator> &t, const unsigned int file_version)

template<class Archive, class Key, class HashFcn, class EqualKey, class Allocator>
inline void save(Archive &ar, const std::unordered_multimap<Key, HashFcn, EqualKey, Allocator> &t, const unsigned int)

template<class Archive, class Key, class HashFcn, class EqualKey, class Allocator>
inline void load(Archive &ar, std::unordered_multimap<Key, HashFcn, EqualKey, Allocator> &t, const unsigned int)

template<class Archive, class Key, class HashFcn, class EqualKey, class Allocator>
inline void serialize(Archive &ar, std::unordered_multimap<Key, HashFcn, EqualKey, Allocator> &t, const unsigned int file_version)

template<class Archive, class Key, class HashFcn, class EqualKey, class Allocator>
inline void save(Archive &ar, const std::unordered_set<Key, HashFcn, EqualKey, Allocator> &t, const unsigned int)

template<class Archive, class Key, class HashFcn, class EqualKey, class Allocator>
inline void load(Archive &ar, std::unordered_set<Key, HashFcn, EqualKey, Allocator> &t, const unsigned int)

template<class Archive, class Key, class HashFcn, class EqualKey, class Allocator>
inline void serialize(Archive &ar, std::unordered_set<Key, HashFcn, EqualKey, Allocator> &t, const unsigned int file_version)

template<class Archive, class Key, class HashFcn, class EqualKey, class Allocator>
inline void save(Archive &ar, const std::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t, const unsigned int)

template<class Archive, class Key, class HashFcn, class EqualKey, class Allocator>
inline void load(Archive &ar, std::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t, const unsigned int)

template<class Archive, class Key, class HashFcn, class EqualKey, class Allocator>
inline void serialize(Archive &ar, std::unordered_multiset<Key, HashFcn, EqualKey, Allocator> &t, const unsigned int file_version)

template<class Archive, class F, class S>
inline void serialize(Archive &ar, std::pair<F, S> &p, const unsigned int)

template<class Archive, class U>
void save(Archive &ar, const STD::valarray<U> &t, const unsigned int)

template<class Archive, class U>
void load(Archive &ar, STD::valarray<U> &t, const unsigned int)

template<class Archive, class U>
inline void serialize(Archive &ar, STD::valarray<U> &t, const unsigned int file_version)

template<class Archive, BOOST_VARIANT_ENUM_PARAMS(class T)>
void save(Archive &ar, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const &v, unsigned int)

template<class Archive, BOOST_VARIANT_ENUM_PARAMS(class T)>
void load(Archive &ar, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> &v, const unsigned int version)

template<class Archive, BOOST_VARIANT_ENUM_PARAMS(class T)>
inline void serialize(Archive &ar, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> &v, const unsigned int file_version)

template<class Archive, class U, class Allocator>
inline void save(Archive &ar, const std::vector<U, Allocator> &t, const unsigned int, boost::mpl::false_)

template<class Archive, class U, class Allocator>
inline void load(Archive &ar, std::vector<U, Allocator> &t, const unsigned int, boost::mpl::false_)

template<class Archive, class U, class Allocator>
inline void save(Archive &ar, const std::vector<U, Allocator> &t, const unsigned int, boost::mpl::true_)

template<class Archive, class U, class Allocator>
inline void load(Archive &ar, std::vector<U, Allocator> &t, const unsigned int, boost::mpl::true_)

template<class Archive, class U, class Allocator>
inline void save(Archive &ar, const std::vector<U, Allocator> &t, const unsigned int file_version)

template<class Archive, class U, class Allocator>
inline void load(Archive &ar, std::vector<U, Allocator> &t, const unsigned int file_version)

template<class Archive, class U, class Allocator>
inline void serialize(Archive &ar, std::vector<U, Allocator> &t, const unsigned int file_version)

template<class Archive, class Allocator>
inline void save(Archive &ar, const std::vector<bool, Allocator> &t, const unsigned int)

template<class Archive, class Allocator>
inline void load(Archive &ar, std::vector<bool, Allocator> &t, const unsigned int)

template<class Archive, class Allocator>
inline void serialize(Archive &ar, std::vector<bool, Allocator> &t, const unsigned int file_version)

inline void *void_upcast(extended_type_info const &derived, extended_type_info const &base, void *const t)

inline void *void_downcast(extended_type_info const &derived, extended_type_info const &base, void *const t)

template<class Derived, class Base> inline I3_DLLEXPORT const void_cast_detail::void_caster & void_cast_register (Derived const *, Base const *)

template<class Archive, class T>
inline void save(Archive &ar, const boost::weak_ptr<T> &t, const unsigned int)

template<class Archive, class T>
inline void load(Archive &ar, boost::weak_ptr<T> &t, const unsigned int)

template<class Archive, class T>
inline void serialize(Archive &ar, boost::weak_ptr<T> &t, const unsigned int file_version)

template<class Archive, class T>
inline void save(Archive &ar, const std::weak_ptr<T> &t, const unsigned int)

template<class Archive, class T>
inline void load(Archive &ar, std::weak_ptr<T> &t, const unsigned int)

template<class Archive, class T>
inline void serialize(Archive &ar, std::weak_ptr<T> &t, const unsigned int file_version)

Variables

class I3_SERIALIZATION_DECL(BOOST_PP_EMPTY()) extended_type_info const unsigned int m_type_info_key

const char *m_key

void *const shared_ptr_helper_id = 0

namespace detail

Typedefs

typedef std::multiset<const extended_type_info*, key_compare> ktmap

Functions

template<class T, class Allocator>
T *get_data(STD::vector<T, Allocator> &v)

template<class T, class Allocator>
T *get_data(STD::vector<T, Allocator> const &v)

template<class T>
T *get_data(STD::valarray<T> &v)

template<class T>
const T *get_data(STD::valarray<T> const &v)

namespace ext

namespace no_rtti_system

Functions

class I3_SERIALIZATION_DECL(BOOST_PP_EMPTY()) extended_type_info_no_rtti_0 ~extended_type_info_no_rtti_0 ()

virtual bool is_less_than(const icecube::serialization::extended_type_info &rhs) const

virtual bool is_equal(const icecube::serialization::extended_type_info &rhs) const

namespace smart_cast_impl

namespace stl

Functions

template<class Archive, class Container, class InputFunction, class R>
inline void load_collection(Archive &ar, Container &s)

template<class Archive, class Container>
inline void save_collection(Archive &ar, const Container &s)

template<class Archive, class Container, class InputFunction>
inline void load_hash_collection(Archive &ar, Container &s)

template<class Archive, class Container>
inline void save_hash_collection(Archive &ar, const Container &s)

template<class Archive, class Container, class InputFunction>
inline void load_unordered_collection(Archive &ar, Container &s)

template<class Archive, class Container>
inline void save_unordered_collection(Archive &ar, const Container &s)

namespace typeid_system

Typedefs

typedef std::multiset<const extended_type_info_typeid_0*, type_compare> tkmap

Functions

class I3_SERIALIZATION_DECL(BOOST_PP_EMPTY()) extended_type_info_typeid_0 return m_ti name ()

extended_type_info_typeid_0(const char *key)

~extended_type_info_typeid_0()

void type_register(const std::type_info &ti)

void type_unregister()

const extended_type_info *get_extended_type_info(const std::type_info &ti) const

virtual bool is_less_than(const extended_type_info &rhs) const

virtual bool is_equal(const extended_type_info &rhs) const

const std::type_info &get_typeid() const

Variables

const std::type_info *m_ti

namespace void_cast_detail

Typedefs

typedef std::set<const void_caster*, void_caster_compare> set_type

typedef icecube::serialization::singleton<set_type> void_caster_registry

Functions

void recursive_register(bool includes_virtual_base = false) const

void recursive_unregister() const

virtual bool has_virtual_base() const = 0

bool operator<(const void_caster &rhs) const

const void_caster &operator*()

virtual void const *upcast(void const *const t) const = 0

virtual void const *downcast(void const *const t) const = 0

void_caster(extended_type_info const *derived, extended_type_info const *base, std::ptrdiff_t difference = 0, void_caster const *const parent = 0)

virtual ~void_caster()

Variables

const extended_type_info *m_derived

const extended_type_info *m_base

std::ptrdiff_t m_difference

void_caster const *const m_parent

namespace std

STL namespace.

Functions

template<class CharType>
basic_ostream<CharType> &operator<<(basic_ostream<CharType> &os, boost::uint64_t t)

template<class CharType>
basic_ostream<CharType> &operator<<(basic_ostream<CharType> &os, boost::int64_t t)

template<class CharType>
basic_istream<CharType> &operator>>(basic_istream<CharType> &is, boost::int64_t &t)

template<class CharType>
basic_istream<CharType> &operator>>(basic_istream<CharType> &is, boost::uint64_t &t)

template<char>
inline back_insert_iterator<basic_string<char>> back_inserter(basic_string<char> &s)

template<wchar_t>
inline back_insert_iterator<basic_string<wchar_t>> back_inserter(basic_string<wchar_t> &s)

file abi_prefix.hpp

#include <boost/config/abi_prefix.hpp>

file abi_suffix.hpp

#include <boost/config/abi_suffix.hpp>

file access.hpp

#include <boost/config.hpp>

#include <serialization/pfto.hpp>

file add_facet.hpp

#include <locale>

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

file archive_exception.cpp

#include <exception>

#include <string>

#include <cstring>

#include <archive/archive_exception.hpp>

Defines

I3_ARCHIVE_SOURCE

file archive_exception.hpp

#include <exception>

#include <boost/assert.hpp>

#include <string>

#include <boost/config.hpp>

#include <boost/preprocessor/empty.hpp>

#include <archive/detail/decl.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file archive_serializer_map.hpp

#include <boost/config.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file array.hpp

#include <boost/config.hpp>

#include <iostream>

#include <cstddef>

#include <array>

#include <serialization/nvp.hpp>

#include <serialization/split_member.hpp>

#include <serialization/wrapper.hpp>

#include <boost/mpl/always.hpp>

#include <boost/mpl/apply.hpp>

#include <boost/mpl/bool.hpp>

#include <boost/type_traits/remove_const.hpp>

#include <boost/array.hpp>

Defines

I3_SERIALIZATION_USE_ARRAY_OPTIMIZATION(Archive)

file assume_abstract.hpp

#include <boost/type_traits/is_abstract.hpp>

Defines

I3_SERIALIZATION_ASSUME_ABSTRACT(T)

file auto_link_archive.hpp

#include <archive/detail/decl.hpp>

#include <boost/config/auto_link.hpp>

Defines

I3_LIB_NAME

file auto_link_warchive.hpp

#include <archive/detail/decl.hpp>

#include <boost/config/auto_link.hpp>

Defines

I3_LIB_NAME

file base64_exception.hpp

#include <boost/config.hpp>

#include <exception>

#include <boost/assert.hpp>

file base64_from_binary.hpp

#include <boost/assert.hpp>

#include <cstddef>

#include <serialization/pfto.hpp>

#include <boost/iterator/transform_iterator.hpp>

#include <archive/iterators/dataflow_exception.hpp>

file base_object.hpp

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/int.hpp>

#include <boost/mpl/bool.hpp>

#include <boost/mpl/identity.hpp>

#include <boost/type_traits/is_base_and_derived.hpp>

#include <boost/type_traits/is_pointer.hpp>

#include <boost/type_traits/is_const.hpp>

#include <boost/type_traits/is_polymorphic.hpp>

#include <boost/static_assert.hpp>

#include <serialization/access.hpp>

#include <serialization/force_include.hpp>

#include <serialization/void_cast_fwd.hpp>

file basic_archive.cpp

#include <archive/basic_archive.hpp>

Defines

I3_ARCHIVE_SOURCE

file basic_archive.hpp

#include <cstring>

#include <boost/assert.hpp>

#include <boost/config.hpp>

#include <boost/cstdint.hpp>

#include <boost/noncopyable.hpp>

#include <boost/integer_traits.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

#include <serialization/level.hpp>

#include <serialization/is_bitwise_serializable.hpp>

Defines

NULL_POINTER_TAG

I3_ARCHIVE_STRONG_TYPEDEF(T, D)

file basic_archive_impl.hpp

#include <set>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_binary_iarchive.hpp

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <serialization/pfto.hpp>

#include <archive/basic_archive.hpp>

#include <archive/detail/common_iarchive.hpp>

#include <serialization/collection_size_type.hpp>

#include <serialization/string.hpp>

#include <serialization/item_version_type.hpp>

#include <boost/integer_traits.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_binary_iprimitive.hpp

#include <iosfwd>

#include <boost/assert.hpp>

#include <locale>

#include <cstring>

#include <cstddef>

#include <streambuf>

#include <string>

#include <boost/config.hpp>

#include <boost/cstdint.hpp>

#include <boost/scoped_ptr.hpp>

#include <serialization/throw_exception.hpp>

#include <boost/integer.hpp>

#include <boost/integer_traits.hpp>

#include <archive/basic_streambuf_locale_saver.hpp>

#include <archive/archive_exception.hpp>

#include <boost/mpl/placeholders.hpp>

#include <serialization/is_bitwise_serializable.hpp>

#include <serialization/array.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_binary_oarchive.hpp

#include <boost/assert.hpp>

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <serialization/pfto.hpp>

#include <boost/integer.hpp>

#include <boost/integer_traits.hpp>

#include <archive/detail/common_oarchive.hpp>

#include <serialization/string.hpp>

#include <serialization/collection_size_type.hpp>

#include <serialization/item_version_type.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_binary_oprimitive.hpp

#include <iosfwd>

#include <boost/assert.hpp>

#include <locale>

#include <streambuf>

#include <string>

#include <cstddef>

#include <boost/config.hpp>

#include <boost/cstdint.hpp>

#include <boost/integer.hpp>

#include <boost/integer_traits.hpp>

#include <boost/scoped_ptr.hpp>

#include <serialization/throw_exception.hpp>

#include <archive/basic_streambuf_locale_saver.hpp>

#include <archive/archive_exception.hpp>

#include <serialization/is_bitwise_serializable.hpp>

#include <boost/mpl/placeholders.hpp>

#include <serialization/array.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_config.hpp

#include <boost/config.hpp>

Defines

I3_ARCHIVE_DECL

file basic_iarchive.cpp

#include <boost/config.hpp>

#include <boost/assert.hpp>

#include <set>

#include <list>

#include <vector>

#include <cstddef>

#include <boost/integer_traits.hpp>

#include <serialization/state_saver.hpp>

#include <serialization/throw_exception.hpp>

#include <serialization/tracking.hpp>

#include <archive/archive_exception.hpp>

#include <archive/detail/decl.hpp>

#include <archive/basic_archive.hpp>

#include <archive/detail/basic_iserializer.hpp>

#include <archive/detail/basic_pointer_iserializer.hpp>

#include <archive/detail/basic_iarchive.hpp>

#include <archive/detail/auto_link_archive.hpp>

Defines

I3_ARCHIVE_SOURCE

I3_SERIALIZATION_SOURCE

file basic_iarchive.hpp

#include <boost/config.hpp>

#include <boost/noncopyable.hpp>

#include <serialization/tracking_enum.hpp>

#include <archive/basic_archive.hpp>

#include <archive/detail/decl.hpp>

#include <archive/detail/helper_collection.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_iserializer.cpp

#include <cstddef>

#include <archive/detail/basic_iserializer.hpp>

Defines

I3_ARCHIVE_SOURCE

file basic_iserializer.hpp

#include <cstdlib>

#include <boost/config.hpp>

#include <archive/basic_archive.hpp>

#include <archive/detail/decl.hpp>

#include <archive/detail/basic_serializer.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_oarchive.cpp

#include <boost/config.hpp>

#include <boost/assert.hpp>

#include <set>

#include <cstddef>

#include <boost/limits.hpp>

#include <serialization/state_saver.hpp>

#include <serialization/throw_exception.hpp>

#include <archive/detail/decl.hpp>

#include <archive/basic_archive.hpp>

#include <archive/detail/basic_oserializer.hpp>

#include <archive/detail/basic_pointer_oserializer.hpp>

#include <archive/detail/basic_oarchive.hpp>

#include <archive/archive_exception.hpp>

#include <serialization/extended_type_info.hpp>

Defines

I3_ARCHIVE_SOURCE

I3_SERIALIZATION_SOURCE

file basic_oarchive.hpp

#include <cstddef>

#include <boost/config.hpp>

#include <boost/noncopyable.hpp>

#include <archive/basic_archive.hpp>

#include <serialization/tracking_enum.hpp>

#include <archive/detail/helper_collection.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_oserializer.cpp

#include <cstddef>

#include <archive/detail/basic_oserializer.hpp>

Defines

I3_ARCHIVE_SOURCE

file basic_oserializer.hpp

#include <cstddef>

#include <boost/config.hpp>

#include <boost/noncopyable.hpp>

#include <archive/basic_archive.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/detail/basic_serializer.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_pointer_iserializer.cpp

#include <archive/detail/basic_pointer_iserializer.hpp>

Defines

I3_ARCHIVE_SOURCE

file basic_pointer_iserializer.hpp

#include <boost/config.hpp>

#include <boost/noncopyable.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/detail/basic_serializer.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_pointer_oserializer.cpp

#include <archive/detail/basic_pointer_oserializer.hpp>

Defines

I3_ARCHIVE_SOURCE

file basic_pointer_oserializer.hpp

#include <boost/config.hpp>

#include <boost/noncopyable.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/detail/basic_serializer.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_serializer.hpp

#include <boost/assert.hpp>

#include <cstddef>

#include <boost/noncopyable.hpp>

#include <boost/config.hpp>

#include <serialization/extended_type_info.hpp>

file basic_serializer_map.cpp

#include <set>

#include <utility>

#include <archive/archive_exception.hpp>

#include <serialization/throw_exception.hpp>

#include <archive/detail/basic_serializer.hpp>

#include <archive/detail/basic_serializer_map.hpp>

Defines

I3_ARCHIVE_SOURCE

I3_SERIALIZATION_SOURCE

file basic_serializer_map.hpp

#include <set>

#include <boost/config.hpp>

#include <boost/noncopyable.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_streambuf_locale_saver.hpp

#include <locale>

#include <streambuf>

#include <boost/config.hpp>

#include <boost/noncopyable.hpp>

file basic_text_iarchive.hpp

#include <boost/config.hpp>

#include <serialization/pfto.hpp>

#include <boost/detail/workaround.hpp>

#include <archive/detail/common_iarchive.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_text_iprimitive.cpp

#include <istream>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/impl/basic_text_iprimitive.ipp>

Defines

I3_ARCHIVE_SOURCE

file basic_text_iprimitive.hpp

#include <boost/assert.hpp>

#include <locale>

#include <cstddef>

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/limits.hpp>

#include <boost/io/ios_state.hpp>

#include <boost/scoped_ptr.hpp>

#include <boost/static_assert.hpp>

#include <serialization/throw_exception.hpp>

#include <archive/archive_exception.hpp>

#include <archive/basic_streambuf_locale_saver.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_text_oarchive.hpp

#include <boost/assert.hpp>

#include <boost/config.hpp>

#include <serialization/pfto.hpp>

#include <boost/detail/workaround.hpp>

#include <archive/detail/common_oarchive.hpp>

#include <serialization/string.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_text_oprimitive.cpp

#include <ostream>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/impl/basic_text_oprimitive.ipp>

Defines

I3_ARCHIVE_SOURCE

file basic_text_oprimitive.hpp

#include <iomanip>

#include <locale>

#include <boost/assert.hpp>

#include <cstddef>

#include <boost/config.hpp>

#include <boost/static_assert.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/io/ios_state.hpp>

#include <boost/type_traits/is_floating_point.hpp>

#include <boost/mpl/bool.hpp>

#include <boost/limits.hpp>

#include <boost/integer.hpp>

#include <boost/scoped_ptr.hpp>

#include <serialization/throw_exception.hpp>

#include <archive/archive_exception.hpp>

#include <archive/basic_streambuf_locale_saver.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_text_wiprimitive.cpp

#include <boost/config.hpp>

#include <istream>

#include <archive/detail/auto_link_warchive.hpp>

#include <archive/impl/basic_text_iprimitive.ipp>

Defines

I3_WARCHIVE_SOURCE

file basic_text_woprimitive.cpp

#include <boost/config.hpp>

#include <ostream>

#include <archive/detail/auto_link_warchive.hpp>

#include <archive/impl/basic_text_oprimitive.ipp>

Defines

I3_WARCHIVE_SOURCE

file basic_xml_archive.cpp

#include <archive/basic_xml_archive.hpp>

Defines

I3_ARCHIVE_SOURCE

file basic_xml_archive.hpp

#include <archive/archive_exception.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_xml_grammar.hpp

#include <string>

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/spirit/include/classic_rule.hpp>

#include <boost/spirit/include/classic_chset.hpp>

#include <archive/basic_archive.hpp>

#include <serialization/tracking.hpp>

#include <serialization/version.hpp>

file basic_xml_iarchive.hpp

#include <boost/config.hpp>

#include <serialization/pfto.hpp>

#include <boost/detail/workaround.hpp>

#include <archive/detail/common_iarchive.hpp>

#include <serialization/nvp.hpp>

#include <serialization/string.hpp>

#include <boost/mpl/assert.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file basic_xml_oarchive.hpp

#include <boost/config.hpp>

#include <archive/detail/common_oarchive.hpp>

#include <serialization/nvp.hpp>

#include <serialization/tracking.hpp>

#include <serialization/string.hpp>

#include <boost/mpl/assert.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file binary_from_base64.hpp

#include <boost/assert.hpp>

#include <serialization/throw_exception.hpp>

#include <serialization/pfto.hpp>

#include <boost/static_assert.hpp>

#include <boost/iterator/transform_iterator.hpp>

#include <archive/iterators/dataflow_exception.hpp>

file binary_iarchive.cpp

#include <istream>

#include <archive/binary_iarchive.hpp>

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/impl/archive_serializer_map.ipp>

#include <archive/impl/basic_binary_iprimitive.ipp>

#include <archive/impl/basic_binary_iarchive.ipp>

Defines

I3_ARCHIVE_SOURCE

file binary_iarchive.hpp

#include <istream>

#include <archive/binary_iarchive_impl.hpp>

#include <archive/detail/register_archive.hpp>

file binary_iarchive_impl.hpp

#include <istream>

#include <serialization/pfto.hpp>

#include <archive/basic_binary_iprimitive.hpp>

#include <archive/basic_binary_iarchive.hpp>

file binary_oarchive.cpp

#include <ostream>

#include <archive/binary_oarchive.hpp>

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/impl/archive_serializer_map.ipp>

#include <archive/impl/basic_binary_oprimitive.ipp>

#include <archive/impl/basic_binary_oarchive.ipp>

Defines

I3_ARCHIVE_SOURCE

file binary_oarchive.hpp

#include <ostream>

#include <boost/config.hpp>

#include <archive/binary_oarchive_impl.hpp>

#include <archive/detail/register_archive.hpp>

file binary_oarchive_impl.hpp

#include <ostream>

#include <boost/config.hpp>

#include <serialization/pfto.hpp>

#include <archive/basic_binary_oprimitive.hpp>

#include <archive/basic_binary_oarchive.hpp>

file binary_object.hpp

#include <boost/assert.hpp>

#include <cstddef>

#include <boost/config.hpp>

#include <boost/preprocessor/stringize.hpp>

#include <serialization/tracking.hpp>

#include <serialization/level.hpp>

#include <serialization/split_member.hpp>

#include <serialization/nvp.hpp>

#include <serialization/wrapper.hpp>

file binary_wiarchive.cpp

#include <boost/config.hpp>

#include <archive/binary_wiarchive.hpp>

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/impl/archive_serializer_map.ipp>

#include <archive/impl/basic_binary_iprimitive.ipp>

#include <archive/impl/basic_binary_iarchive.ipp>

Defines

I3_WARCHIVE_SOURCE

file binary_wiarchive.hpp

#include <boost/config.hpp>

#include <istream>

#include <archive/binary_iarchive_impl.hpp>

#include <archive/detail/register_archive.hpp>

file binary_woarchive.cpp

#include <boost/config.hpp>

#include <archive/binary_woarchive.hpp>

#include <archive/impl/archive_serializer_map.ipp>

#include <archive/impl/basic_binary_oprimitive.ipp>

#include <archive/impl/basic_binary_oarchive.ipp>

Defines

I3_WARCHIVE_SOURCE

file binary_woarchive.hpp

#include <boost/config.hpp>

#include <ostream>

#include <archive/binary_oarchive_impl.hpp>

#include <archive/detail/register_archive.hpp>

file bitset.hpp

#include <bitset>

#include <cstddef>

#include <cstdint>

#include <boost/config.hpp>

#include <serialization/split_free.hpp>

#include <serialization/nvp.hpp>

Provides Boost.Serialization support for std::bitset.

SPDX-FileCopyrightText: The IceTray Contributors SPDX-License-Identifier: BSL-1.0

Author

David Schultz

Author

Chris Weaver Boost Software License 1.0

file check.hpp

#include <boost/config.hpp>

#include <boost/static_assert.hpp>

#include <boost/type_traits/is_const.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/or.hpp>

#include <boost/mpl/equal_to.hpp>

#include <boost/mpl/int.hpp>

#include <boost/mpl/not.hpp>

#include <boost/mpl/greater.hpp>

#include <boost/mpl/assert.hpp>

#include <serialization/static_warning.hpp>

#include <serialization/version.hpp>

#include <serialization/level.hpp>

#include <serialization/tracking.hpp>

#include <serialization/wrapper.hpp>

file codecvt_null.cpp

#include <archive/codecvt_null.hpp>

Defines

I3_WARCHIVE_SOURCE

file codecvt_null.hpp

#include <locale>

#include <cstddef>

#include <cwchar>

#include <boost/config.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file collection_size_type.hpp

#include <cstddef>

#include <serialization/strong_typedef.hpp>

#include <serialization/level.hpp>

#include <serialization/split_free.hpp>

#include <serialization/is_bitwise_serializable.hpp>

file collection_traits.hpp

#include <boost/config.hpp>

#include <boost/mpl/integral_c.hpp>

#include <boost/mpl/integral_c_tag.hpp>

#include <boost/cstdint.hpp>

#include <boost/integer_traits.hpp>

#include <climits>

#include <serialization/level.hpp>

Defines

I3_SERIALIZATION_COLLECTION_TRAITS_HELPER(T, C)

I3_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)

I3_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)

I3_SERIALIZATION_COLLECTION_TRAITS(C)

file collections_load_imp.hpp

#include <cassert>

#include <cstddef>

#include <boost/version.hpp>

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <serialization/access.hpp>

#include <serialization/nvp.hpp>

#include <serialization/detail/stack_constructor.hpp>

#include <serialization/collection_size_type.hpp>

#include <serialization/item_version_type.hpp>

file collections_save_imp.hpp

#include <boost/config.hpp>

#include <serialization/nvp.hpp>

#include <serialization/serialization.hpp>

#include <serialization/version.hpp>

#include <serialization/collection_size_type.hpp>

file common_iarchive.hpp

#include <boost/config.hpp>

#include <archive/detail/basic_iarchive.hpp>

#include <archive/detail/basic_pointer_iserializer.hpp>

#include <archive/detail/interface_iarchive.hpp>

file common_oarchive.hpp

#include <boost/config.hpp>

#include <archive/detail/basic_oarchive.hpp>

#include <archive/detail/interface_oarchive.hpp>

file complex.hpp

#include <complex>

#include <boost/config.hpp>

#include <serialization/nvp.hpp>

#include <serialization/is_bitwise_serializable.hpp>

#include <serialization/split_free.hpp>

file config.hpp

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/preprocessor/facilities/empty.hpp>

#include <boost/config/auto_link.hpp>

Defines

I3_SERIALIZATION_DECL(T)

I3_LIB_NAME

file dataflow.hpp

#include <boost/assert.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/if.hpp>

#include <boost/mpl/bool.hpp>

#include <boost/mpl/apply.hpp>

#include <boost/mpl/plus.hpp>

#include <boost/mpl/int.hpp>

#include <boost/type_traits/is_convertible.hpp>

#include <boost/type_traits/is_base_and_derived.hpp>

#include <boost/type_traits/is_pointer.hpp>

#include <boost/iterator/iterator_adaptor.hpp>

#include <boost/iterator/iterator_traits.hpp>

#include <boost/static_assert.hpp>

file dataflow_exception.hpp

#include <boost/config.hpp>

#include <exception>

#include <boost/assert.hpp>

file decl.hpp

#include <boost/config.hpp>

#include <boost/preprocessor/facilities/empty.hpp>

Defines

I3_ARCHIVE_DECL(T)

I3_WARCHIVE_DECL(T)

I3_ARCHIVE_OR_WARCHIVE_DECL(T)

file deque.hpp

#include <deque>

#include <boost/config.hpp>

#include <serialization/collections_save_imp.hpp>

#include <serialization/collections_load_imp.hpp>

#include <serialization/split_free.hpp>

#include <serialization/collection_traits.hpp>

file dinkumware.hpp

#include <iterator>

#include <string>

#include <boost/config.hpp>

#include <boost/cstdint.hpp>

file dynamic_bitset.hpp

#include <bitset>

#include <cstddef>

#include <cstdint>

#include <boost/config.hpp>

#include <serialization/split_free.hpp>

#include <serialization/nvp.hpp>

#include <serialization/vector.hpp>

#include <boost/dynamic_bitset.hpp>

Provides Boost.Serialization support for boost::dynamic_bitset.

SPDX-FileCopyrightText: The IceTray Contributors SPDX-License-Identifier: BSL-1.0

Author

David Schultz

Author

Chris Weaver Boost Software License 1.0

file ephemeral.hpp

#include <utility>

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/mpl/integral_c.hpp>

#include <boost/mpl/integral_c_tag.hpp>

#include <serialization/level.hpp>

#include <serialization/tracking.hpp>

#include <serialization/split_member.hpp>

#include <serialization/base_object.hpp>

#include <serialization/traits.hpp>

#include <serialization/wrapper.hpp>

file escape.hpp

#include <boost/assert.hpp>

#include <cstddef>

#include <boost/iterator/iterator_adaptor.hpp>

#include <boost/iterator/iterator_traits.hpp>

file export.hpp

#include <utility>

#include <cstddef>

#include <boost/config.hpp>

#include <boost/static_assert.hpp>

#include <boost/preprocessor/stringize.hpp>

#include <boost/type_traits/is_polymorphic.hpp>

#include <boost/mpl/assert.hpp>

#include <boost/mpl/and.hpp>

#include <boost/mpl/not.hpp>

#include <boost/mpl/bool.hpp>

#include <serialization/extended_type_info.hpp>

#include <serialization/static_warning.hpp>

#include <serialization/assume_abstract.hpp>

#include <serialization/force_include.hpp>

#include <serialization/singleton.hpp>

#include <archive/detail/register_archive.hpp>

#include <iostream>

Defines

I3_CLASS_EXPORT_IMPLEMENT(T)

I3_CLASS_EXPORT_KEY2(T, K)

I3_CLASS_EXPORT_KEY(T)

I3_CLASS_EXPORT_GUID(T, K)

I3_SERIALIZATION_MWERKS_BASE_AND_DERIVED(Base, Derived)

I3_CLASS_EXPORT_CHECK(T)

I3_CLASS_EXPORT(T)

file extended_type_info.cpp

#include <algorithm>

#include <set>

#include <utility>

#include <boost/assert.hpp>

#include <cstddef>

#include <boost/config.hpp>

#include <cstring>

#include <serialization/singleton.hpp>

#include <serialization/force_include.hpp>

#include <serialization/extended_type_info.hpp>

Defines

I3_SERIALIZATION_SOURCE

file extended_type_info.hpp

#include <cstdarg>

#include <boost/assert.hpp>

#include <cstddef>

#include <boost/config.hpp>

#include <boost/noncopyable.hpp>

#include <boost/mpl/bool.hpp>

#include <serialization/config.hpp>

#include <boost/config/abi_prefix.hpp>

#include <boost/config/abi_suffix.hpp>

Defines

I3_SERIALIZATION_MAX_KEY_SIZE

file extended_type_info_no_rtti.cpp

#include <cstring>

#include <cstddef>

#include <boost/assert.hpp>

#include <boost/config.hpp>

#include <serialization/extended_type_info_no_rtti.hpp>

Defines

I3_SERIALIZATION_SOURCE

EXTENDED_TYPE_INFO_NO_RTTI_KEY

file extended_type_info_no_rtti.hpp

#include <boost/assert.hpp>

#include <boost/config.hpp>

#include <boost/static_assert.hpp>

#include <boost/mpl/if.hpp>

#include <boost/type_traits/is_polymorphic.hpp>

#include <boost/type_traits/remove_const.hpp>

#include <serialization/static_warning.hpp>

#include <serialization/singleton.hpp>

#include <serialization/extended_type_info.hpp>

#include <serialization/factory.hpp>

#include <serialization/throw_exception.hpp>

#include <serialization/config.hpp>

#include <serialization/access.hpp>

#include <boost/config/abi_prefix.hpp>

#include <boost/config/abi_suffix.hpp>

Defines

I3_SERIALIZATION_DEFAULT_TYPE_INFO

file extended_type_info_typeid.cpp

#include <algorithm>

#include <set>

#include <boost/assert.hpp>

#include <typeinfo>

#include <cstddef>

#include <serialization/singleton.hpp>

#include <serialization/extended_type_info_typeid.hpp>

Defines

I3_SERIALIZATION_SOURCE

EXTENDED_TYPE_INFO_TYPE_KEY

file extended_type_info_typeid.hpp

#include <typeinfo>

#include <cstdarg>

#include <boost/assert.hpp>

#include <boost/config.hpp>

#include <boost/static_assert.hpp>

#include <serialization/static_warning.hpp>

#include <boost/type_traits/is_polymorphic.hpp>

#include <boost/type_traits/remove_const.hpp>

#include <serialization/config.hpp>

#include <serialization/singleton.hpp>

#include <serialization/extended_type_info.hpp>

#include <serialization/factory.hpp>

#include <serialization/access.hpp>

#include <boost/mpl/if.hpp>

#include <boost/config/abi_prefix.hpp>

#include <boost/config/abi_suffix.hpp>

Defines

I3_SERIALIZATION_DEFAULT_TYPE_INFO

file factory.hpp

#include <cstdarg>

#include <cstddef>

#include <boost/preprocessor/control/if.hpp>

#include <boost/preprocessor/comparison/greater.hpp>

#include <boost/preprocessor/facilities/empty.hpp>

Defines

I3_SERIALIZATION_FACTORY(N, T, A0, A1, A2, A3)

I3_SERIALIZATION_FACTORY_4(T, A0, A1, A2, A3)

I3_SERIALIZATION_FACTORY_3(T, A0, A1, A2)

I3_SERIALIZATION_FACTORY_2(T, A0, A1)

I3_SERIALIZATION_FACTORY_1(T, A0)

I3_SERIALIZATION_FACTORY_0(T)

file force_include.hpp

#include <boost/config.hpp>

Defines

I3_SERIALIZATION_USED

I3_DLLEXPORT

file forward_list.hpp

#include <cstddef>

#include <forward_list>

#include <iterator>

#include <boost/config.hpp>

#include <serialization/collections_save_imp.hpp>

#include <serialization/collections_load_imp.hpp>

#include <serialization/split_free.hpp>

#include <serialization/nvp.hpp>

#include <archive/basic_archive.hpp>

#include <serialization/collection_traits.hpp>

file get_data.hpp

#include <vector>

#include <valarray>

Defines

STD

file hash_collections_load_imp.hpp

#include <boost/config.hpp>

#include <archive/detail/basic_iarchive.hpp>

#include <serialization/nvp.hpp>

#include <serialization/collection_size_type.hpp>

#include <serialization/item_version_type.hpp>

file hash_collections_save_imp.hpp

#include <boost/config.hpp>

#include <serialization/nvp.hpp>

#include <serialization/serialization.hpp>

#include <serialization/version.hpp>

#include <serialization/collection_size_type.hpp>

#include <serialization/item_version_type.hpp>

file hash_map.hpp

#include <boost/config.hpp>

file hash_set.hpp

#include <boost/config.hpp>

file head_iterator.hpp

#include <boost/iterator/iterator_adaptor.hpp>

#include <boost/iterator/iterator_traits.hpp>

file helper_collection.hpp

#include <cstddef>

#include <vector>

#include <utility>

#include <memory>

#include <algorithm>

#include <boost/config.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/make_shared.hpp>

file insert_linebreaks.hpp

#include <boost/assert.hpp>

#include <boost/config.hpp>

#include <serialization/pfto.hpp>

#include <boost/iterator/iterator_adaptor.hpp>

#include <boost/iterator/iterator_traits.hpp>

file interface_iarchive.hpp

#include <cstddef>

#include <boost/cstdint.hpp>

#include <boost/mpl/bool.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/detail/iserializer.hpp>

#include <serialization/singleton.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file interface_oarchive.hpp

#include <cstddef>

#include <boost/cstdint.hpp>

#include <boost/mpl/bool.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/detail/oserializer.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <serialization/singleton.hpp>

#include <archive/detail/abi_suffix.hpp>

file is_bitwise_serializable.hpp

#include <boost/mpl/bool.hpp>

#include <boost/type_traits/is_arithmetic.hpp>

This header provides a traits class for determining whether a class can be serialized (in a non-portable way) just by copying the bits.

Defines

I3_IS_BITWISE_SERIALIZABLE(T)

file iserializer.hpp

#include <new>

#include <cstddef>

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/static_assert.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/identity.hpp>

#include <boost/mpl/greater_equal.hpp>

#include <boost/mpl/equal_to.hpp>

#include <boost/mpl/bool.hpp>

#include <boost/core/no_exceptions_support.hpp>

#include <serialization/extended_type_info_typeid.hpp>

#include <serialization/throw_exception.hpp>

#include <serialization/smart_cast.hpp>

#include <serialization/static_warning.hpp>

#include <boost/type_traits/is_pointer.hpp>

#include <boost/type_traits/is_enum.hpp>

#include <boost/type_traits/is_const.hpp>

#include <boost/type_traits/remove_const.hpp>

#include <boost/type_traits/remove_extent.hpp>

#include <boost/type_traits/is_polymorphic.hpp>

#include <serialization/assume_abstract.hpp>

#include <serialization/serialization.hpp>

#include <serialization/version.hpp>

#include <serialization/level.hpp>

#include <serialization/tracking.hpp>

#include <serialization/type_info_implementation.hpp>

#include <serialization/nvp.hpp>

#include <serialization/void_cast.hpp>

#include <serialization/array.hpp>

#include <serialization/collection_size_type.hpp>

#include <serialization/singleton.hpp>

#include <serialization/wrapper.hpp>

#include <archive/archive_exception.hpp>

#include <archive/detail/basic_iarchive.hpp>

#include <archive/detail/basic_iserializer.hpp>

#include <archive/detail/basic_pointer_iserializer.hpp>

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/detail/check.hpp>

file istream_iterator.hpp

#include <cstddef>

#include <istream>

#include <boost/iterator/iterator_facade.hpp>

file item_version_type.hpp

#include <boost/cstdint.hpp>

#include <boost/integer_traits.hpp>

#include <serialization/level.hpp>

#include <serialization/is_bitwise_serializable.hpp>

#include <boost/assert.hpp>

file level.hpp

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/type_traits/is_fundamental.hpp>

#include <boost/type_traits/is_enum.hpp>

#include <boost/type_traits/is_array.hpp>

#include <boost/type_traits/is_class.hpp>

#include <boost/type_traits/is_base_and_derived.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/int.hpp>

#include <boost/mpl/integral_c.hpp>

#include <boost/mpl/integral_c_tag.hpp>

#include <serialization/level_enum.hpp>

Defines

I3_CLASS_IMPLEMENTATION(T, E)

file level_enum.hpp

file list.hpp

#include <list>

#include <boost/config.hpp>

#include <serialization/collections_save_imp.hpp>

#include <serialization/collections_load_imp.hpp>

#include <serialization/split_free.hpp>

#include <serialization/collection_traits.hpp>

file map.hpp

#include <map>

#include <boost/config.hpp>

#include <serialization/utility.hpp>

#include <serialization/collections_save_imp.hpp>

#include <serialization/collections_load_imp.hpp>

#include <serialization/split_free.hpp>

file mb_from_wchar.hpp

#include <boost/assert.hpp>

#include <cstddef>

#include <cstdlib>

#include <boost/config.hpp>

#include <serialization/pfto.hpp>

#include <boost/iterator/iterator_adaptor.hpp>

file nvp.hpp

#include <utility>

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/mpl/integral_c.hpp>

#include <boost/mpl/integral_c_tag.hpp>

#include <serialization/level.hpp>

#include <serialization/tracking.hpp>

#include <serialization/split_member.hpp>

#include <serialization/base_object.hpp>

#include <serialization/traits.hpp>

#include <serialization/wrapper.hpp>

#include <boost/preprocessor/stringize.hpp>

Defines

I3_SERIALIZATION_NVP(name)

I3_SERIALIZATION_BASE_OBJECT_NVP(name)

file optional.hpp

#include <boost/config.hpp>

#include <archive/detail/basic_iarchive.hpp>

#include <boost/optional.hpp>

#include <serialization/item_version_type.hpp>

#include <serialization/split_free.hpp>

#include <serialization/level.hpp>

#include <serialization/nvp.hpp>

#include <serialization/version.hpp>

#include <serialization/detail/stack_constructor.hpp>

file oserializer.hpp

#include <boost/assert.hpp>

#include <cstddef>

#include <boost/config.hpp>

#include <boost/static_assert.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/equal_to.hpp>

#include <boost/mpl/greater_equal.hpp>

#include <boost/mpl/identity.hpp>

#include <serialization/extended_type_info_typeid.hpp>

#include <serialization/throw_exception.hpp>

#include <serialization/smart_cast.hpp>

#include <serialization/assume_abstract.hpp>

#include <serialization/static_warning.hpp>

#include <boost/type_traits/is_pointer.hpp>

#include <boost/type_traits/is_enum.hpp>

#include <boost/type_traits/is_const.hpp>

#include <boost/type_traits/is_polymorphic.hpp>

#include <boost/type_traits/remove_extent.hpp>

#include <serialization/serialization.hpp>

#include <serialization/version.hpp>

#include <serialization/level.hpp>

#include <serialization/tracking.hpp>

#include <serialization/type_info_implementation.hpp>

#include <serialization/nvp.hpp>

#include <serialization/void_cast.hpp>

#include <serialization/array.hpp>

#include <serialization/collection_size_type.hpp>

#include <serialization/singleton.hpp>

#include <archive/archive_exception.hpp>

#include <archive/detail/basic_oarchive.hpp>

#include <archive/detail/basic_oserializer.hpp>

#include <archive/detail/basic_pointer_oserializer.hpp>

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/detail/check.hpp>

file ostream_iterator.hpp

#include <ostream>

#include <boost/iterator/iterator_facade.hpp>

file pfto.hpp

#include <boost/config.hpp>

Defines

I3_PFTO

I3_PFTO_WRAPPER(T)

I3_MAKE_PFTO_WRAPPER(t)

file polymorphic_binary_iarchive.hpp

#include <boost/config.hpp>

#include <archive/binary_iarchive.hpp>

#include <archive/detail/polymorphic_iarchive_route.hpp>

file polymorphic_binary_oarchive.hpp

#include <boost/config.hpp>

#include <archive/binary_oarchive.hpp>

#include <archive/detail/polymorphic_oarchive_route.hpp>

file polymorphic_iarchive.cpp

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/impl/archive_serializer_map.ipp>

#include <archive/polymorphic_iarchive.hpp>

Defines

I3_ARCHIVE_SOURCE

file polymorphic_iarchive.hpp

#include <cstddef>

#include <climits>

#include <string>

#include <boost/config.hpp>

#include <boost/cstdint.hpp>

#include <serialization/pfto.hpp>

#include <archive/detail/iserializer.hpp>

#include <archive/detail/interface_iarchive.hpp>

#include <serialization/nvp.hpp>

#include <archive/detail/register_archive.hpp>

#include <archive/detail/decl.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file polymorphic_iarchive_route.hpp

#include <string>

#include <ostream>

#include <cstddef>

#include <boost/config.hpp>

#include <boost/cstdint.hpp>

#include <boost/integer_traits.hpp>

#include <archive/polymorphic_iarchive.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file polymorphic_oarchive.cpp

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/impl/archive_serializer_map.ipp>

#include <archive/polymorphic_oarchive.hpp>

Defines

I3_ARCHIVE_SOURCE

file polymorphic_oarchive.hpp

#include <cstddef>

#include <climits>

#include <string>

#include <boost/config.hpp>

#include <boost/cstdint.hpp>

#include <serialization/pfto.hpp>

#include <archive/detail/oserializer.hpp>

#include <archive/detail/interface_oarchive.hpp>

#include <serialization/nvp.hpp>

#include <archive/detail/register_archive.hpp>

#include <archive/detail/decl.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file polymorphic_oarchive_route.hpp

#include <string>

#include <ostream>

#include <cstddef>

#include <boost/config.hpp>

#include <boost/cstdint.hpp>

#include <boost/integer_traits.hpp>

#include <archive/polymorphic_oarchive.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file polymorphic_text_iarchive.hpp

#include <boost/config.hpp>

#include <archive/text_iarchive.hpp>

#include <archive/detail/polymorphic_iarchive_route.hpp>

file polymorphic_text_oarchive.hpp

#include <boost/config.hpp>

#include <archive/text_oarchive.hpp>

#include <archive/detail/polymorphic_oarchive_route.hpp>

file polymorphic_text_wiarchive.hpp

#include <boost/config.hpp>

#include <archive/text_wiarchive.hpp>

#include <archive/detail/polymorphic_iarchive_route.hpp>

file polymorphic_text_woarchive.hpp

#include <boost/config.hpp>

#include <archive/text_woarchive.hpp>

#include <archive/detail/polymorphic_oarchive_route.hpp>

file polymorphic_xml_iarchive.hpp

#include <boost/config.hpp>

#include <archive/xml_iarchive.hpp>

#include <archive/detail/polymorphic_iarchive_route.hpp>

file polymorphic_xml_oarchive.hpp

#include <boost/config.hpp>

#include <archive/xml_oarchive.hpp>

#include <archive/detail/polymorphic_oarchive_route.hpp>

file polymorphic_xml_wiarchive.hpp

#include <boost/config.hpp>

#include <archive/xml_wiarchive.hpp>

#include <archive/detail/polymorphic_iarchive_route.hpp>

file polymorphic_xml_woarchive.hpp

#include <boost/config.hpp>

#include <archive/xml_woarchive.hpp>

#include <archive/detail/polymorphic_oarchive_route.hpp>

file portable_binary_archive.cpp

#include <limits>

#include <archive/portable_binary_archive.hpp>

#include <archive/impl/archive_serializer_map.ipp>

file portable_binary_archive.hpp

#include <streambuf>

#include <archive/basic_archive.hpp>

#include <archive/shared_ptr_helper.hpp>

#include <serialization/shared_ptr_helper.hpp>

#include <archive/detail/register_archive.hpp>

#include <archive/detail/common_iarchive.hpp>

#include <archive/detail/common_oarchive.hpp>

#include <archive/detail/iserializer.hpp>

#include <archive/detail/oserializer.hpp>

#include <serialization/is_bitwise_serializable.hpp>

#include <serialization/array.hpp>

#include <sys/types.h>

#include <cstring>

Defines

sv_override(a, b)

ld_override(a, b, c, d)

file priority_queue.hpp

#include <queue>

#include <boost/config.hpp>

#include <serialization/collection_traits.hpp>

Defines

STD

file queue.hpp

#include <queue>

#include <boost/config.hpp>

#include <serialization/collection_traits.hpp>

Defines

STD

file register_archive.hpp

Defines

I3_SERIALIZATION_REGISTER_ARCHIVE(Archive)

file remove_whitespace.hpp

#include <boost/assert.hpp>

#include <serialization/pfto.hpp>

#include <boost/iterator/iterator_adaptor.hpp>

#include <boost/iterator/filter_iterator.hpp>

#include <boost/iterator/iterator_traits.hpp>

#include <cwctype>

#include <cctype>

file scoped_ptr.hpp

#include <boost/config.hpp>

#include <boost/scoped_ptr.hpp>

#include <serialization/nvp.hpp>

#include <serialization/split_free.hpp>

file serialization.hpp

#include <boost/config.hpp>

#include <serialization/strong_typedef.hpp>

#include <serialization/pfto.hpp>

#include <serialization/access.hpp>

file set.hpp

#include <set>

#include <boost/config.hpp>

#include <serialization/collections_save_imp.hpp>

#include <serialization/collections_load_imp.hpp>

#include <serialization/split_free.hpp>

#include <serialization/collection_traits.hpp>

file shared_count_132.hpp

#include <boost/config.hpp>

#include <boost/checked_delete.hpp>

#include <serialization/throw_exception.hpp>

#include <boost/detail/lightweight_mutex.hpp>

#include <functional>

#include <exception>

#include <new>

#include <typeinfo>

#include <cstddef>

file shared_ptr.hpp

#include <cstddef>

#include <memory>

#include <boost/config.hpp>

#include <boost/mpl/integral_c.hpp>

#include <boost/mpl/integral_c_tag.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/shared_ptr.hpp>

#include <serialization/shared_ptr_helper.hpp>

#include <serialization/split_free.hpp>

#include <serialization/nvp.hpp>

#include <serialization/version.hpp>

#include <serialization/tracking.hpp>

#include <boost/static_assert.hpp>

Defines

I3_SERIALIZATION_SHARED_PTR(T)

I3_SERIALIZATION_SHARED_PTR(T)

file detail/shared_ptr_132.hpp

#include <boost/config.hpp>

#include <boost/assert.hpp>

#include <boost/checked_delete.hpp>

#include <serialization/throw_exception.hpp>

#include <boost/detail/workaround.hpp>

#include <serialization/access.hpp>

#include <serialization/detail/shared_count_132.hpp>

#include <algorithm>

#include <functional>

#include <typeinfo>

#include <iosfwd>

file shared_ptr_132.hpp

#include <boost/config.hpp>

#include <list>

#include <cstddef>

#include <serialization/assume_abstract.hpp>

#include <serialization/split_free.hpp>

#include <serialization/nvp.hpp>

#include <serialization/tracking.hpp>

#include <serialization/void_cast.hpp>

#include <serialization/detail/shared_ptr_132.hpp>

Defines

I3_SHARED_POINTER_EXPORT_GUID(T, K)

I3_SHARED_POINTER_EXPORT(T)

file shared_ptr_helper.cpp

#include <map>

#include <list>

#include <utility>

#include <cstddef>

#include <cassert>

#include <serialization/throw_exception.hpp>

#include <serialization/void_cast.hpp>

#include <serialization/extended_type_info.hpp>

#include <serialization/shared_ptr_helper.hpp>

#include <archive/archive_exception.hpp>

Defines

I3_ARCHIVE_SOURCE

I3_SERIALIZATION_SOURCE

file archive/shared_ptr_helper.hpp

#include <set>

#include <list>

#include <utility>

#include <cstddef>

#include <boost/config.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/type_traits/is_polymorphic.hpp>

#include <serialization/type_info_implementation.hpp>

#include <serialization/shared_ptr_132.hpp>

#include <serialization/throw_exception.hpp>

#include <archive/archive_exception.hpp>

#include <archive/detail/decl.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file serialization/shared_ptr_helper.hpp

#include <map>

#include <list>

#include <utility>

#include <cstddef>

#include <boost/config.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/type_traits/is_polymorphic.hpp>

#include <boost/mpl/if.hpp>

#include <serialization/singleton.hpp>

#include <serialization/extended_type_info.hpp>

#include <serialization/throw_exception.hpp>

#include <archive/archive_exception.hpp>

#include <archive/detail/decl.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file shared_ptr_nmt_132.hpp

#include <boost/assert.hpp>

#include <boost/checked_delete.hpp>

#include <serialization/throw_exception.hpp>

#include <boost/detail/atomic_count.hpp>

#include <algorithm>

#include <functional>

#include <new>

Defines

I3_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED

file singleton.hpp

#include <boost/assert.hpp>

#include <boost/config.hpp>

#include <boost/noncopyable.hpp>

#include <serialization/force_include.hpp>

file slist.hpp

#include <cstddef>

#include <boost/config.hpp>

file smart_cast.hpp

#include <exception>

#include <typeinfo>

#include <cstddef>

#include <boost/config.hpp>

#include <boost/static_assert.hpp>

#include <boost/type_traits/is_base_and_derived.hpp>

#include <boost/type_traits/is_polymorphic.hpp>

#include <boost/type_traits/is_pointer.hpp>

#include <boost/type_traits/is_reference.hpp>

#include <boost/type_traits/is_same.hpp>

#include <boost/type_traits/remove_pointer.hpp>

#include <boost/type_traits/remove_reference.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/if.hpp>

#include <boost/mpl/or.hpp>

#include <boost/mpl/and.hpp>

#include <boost/mpl/not.hpp>

#include <boost/mpl/identity.hpp>

#include <serialization/throw_exception.hpp>

file split_free.hpp

#include <boost/config.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/identity.hpp>

#include <serialization/serialization.hpp>

Defines

I3_SERIALIZATION_SPLIT_FREE(T)

file split_member.hpp

#include <boost/config.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/identity.hpp>

#include <serialization/access.hpp>

Defines

I3_SERIALIZATION_SPLIT_MEMBER()

file stack.hpp

#include <stack>

#include <boost/config.hpp>

#include <serialization/collection_traits.hpp>

Defines

STD

file stack_constructor.hpp

#include <boost/aligned_storage.hpp>

file state_saver.hpp

#include <boost/config.hpp>

#include <exception>

#include <boost/call_traits.hpp>

#include <boost/noncopyable.hpp>

#include <boost/type_traits/has_nothrow_copy.hpp>

#include <boost/core/no_exceptions_support.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/identity.hpp>

file static_warning.hpp

#include <boost/config.hpp>

#include <boost/mpl/bool.hpp>

#include <boost/mpl/print.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/static_assert.hpp>

Defines

I3_STATIC_ASSERT_UNUSED_ATTRIBUTE

I3_SERIALIZATION_BSW(B, L)

file stl_port.cpp

#include <boost/config.hpp>

file string.hpp

#include <string>

#include <boost/config.hpp>

#include <serialization/level.hpp>

file strong_typedef.hpp

#include <boost/config.hpp>

#include <boost/operators.hpp>

Defines

I3_STRONG_TYPEDEF(T, D)

file text_iarchive.cpp

#include <archive/text_iarchive.hpp>

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/impl/archive_serializer_map.ipp>

#include <archive/impl/basic_text_iarchive.ipp>

#include <archive/impl/text_iarchive_impl.ipp>

Defines

I3_ARCHIVE_SOURCE

file text_iarchive.hpp

#include <istream>

#include <boost/config.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/basic_text_iprimitive.hpp>

#include <archive/basic_text_iarchive.hpp>

#include <archive/detail/register_archive.hpp>

#include <serialization/item_version_type.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file text_oarchive.cpp

#include <archive/text_oarchive.hpp>

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/impl/archive_serializer_map.ipp>

#include <archive/impl/basic_text_oarchive.ipp>

#include <archive/impl/text_oarchive_impl.ipp>

Defines

I3_ARCHIVE_SOURCE

file text_oarchive.hpp

#include <ostream>

#include <cstddef>

#include <boost/config.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/basic_text_oprimitive.hpp>

#include <archive/basic_text_oarchive.hpp>

#include <archive/detail/register_archive.hpp>

#include <serialization/item_version_type.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file text_wiarchive.cpp

#include <boost/config.hpp>

#include <archive/text_wiarchive.hpp>

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/impl/archive_serializer_map.ipp>

#include <archive/impl/basic_text_iarchive.ipp>

#include <archive/impl/text_wiarchive_impl.ipp>

Defines

I3_WARCHIVE_SOURCE

file text_wiarchive.hpp

#include <boost/config.hpp>

#include <istream>

#include <archive/detail/auto_link_warchive.hpp>

#include <archive/basic_text_iprimitive.hpp>

#include <archive/basic_text_iarchive.hpp>

#include <archive/detail/register_archive.hpp>

#include <serialization/item_version_type.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file text_woarchive.cpp

#include <boost/config.hpp>

#include <archive/text_woarchive.hpp>

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/impl/archive_serializer_map.ipp>

#include <archive/impl/basic_text_oarchive.ipp>

#include <archive/impl/text_woarchive_impl.ipp>

Defines

I3_WARCHIVE_SOURCE

file text_woarchive.hpp

#include <boost/config.hpp>

#include <ostream>

#include <cstddef>

#include <archive/detail/auto_link_warchive.hpp>

#include <archive/basic_text_oprimitive.hpp>

#include <archive/basic_text_oarchive.hpp>

#include <archive/detail/register_archive.hpp>

#include <serialization/item_version_type.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file throw_exception.hpp

#include <boost/config.hpp>

#include <exception>

file tmpdir.hpp

#include <cstdlib>

#include <cstddef>

#include <boost/config.hpp>

file tracking.hpp

#include <boost/config.hpp>

#include <boost/static_assert.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/identity.hpp>

#include <boost/mpl/int.hpp>

#include <boost/mpl/equal_to.hpp>

#include <boost/mpl/greater.hpp>

#include <boost/mpl/integral_c_tag.hpp>

#include <boost/type_traits/is_base_and_derived.hpp>

#include <boost/type_traits/is_pointer.hpp>

#include <serialization/level.hpp>

#include <serialization/tracking_enum.hpp>

#include <serialization/type_info_implementation.hpp>

Defines

I3_CLASS_TRACKING(T, E)

file tracking_enum.hpp

file traits.hpp

#include <boost/config.hpp>

#include <boost/static_assert.hpp>

#include <boost/mpl/int.hpp>

#include <boost/mpl/bool.hpp>

#include <serialization/level_enum.hpp>

#include <serialization/tracking_enum.hpp>

file transform_width.hpp

#include <serialization/pfto.hpp>

#include <boost/iterator/iterator_adaptor.hpp>

#include <boost/iterator/iterator_traits.hpp>

#include <algorithm>

file type_info_implementation.hpp

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/static_assert.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/identity.hpp>

#include <boost/type_traits/is_base_and_derived.hpp>

#include <serialization/traits.hpp>

Defines

I3_CLASS_TYPE_INFO(T, ETI)

file unescape.hpp

#include <boost/assert.hpp>

#include <boost/iterator/iterator_adaptor.hpp>

#include <boost/pointee.hpp>

file unique_ptr.hpp

#include <memory>

#include <serialization/split_free.hpp>

#include <serialization/nvp.hpp>

file unordered_collections_load_imp.hpp

#include <boost/assert.hpp>

#include <cstddef>

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <archive/detail/basic_iarchive.hpp>

#include <serialization/access.hpp>

#include <serialization/nvp.hpp>

#include <serialization/detail/stack_constructor.hpp>

#include <serialization/collection_size_type.hpp>

#include <serialization/item_version_type.hpp>

file unordered_collections_save_imp.hpp

#include <boost/config.hpp>

#include <serialization/nvp.hpp>

#include <serialization/serialization.hpp>

#include <serialization/version.hpp>

#include <serialization/collection_size_type.hpp>

#include <serialization/item_version_type.hpp>

file unordered_map.hpp

#include <boost/config.hpp>

#include <unordered_map>

#include <serialization/utility.hpp>

#include <serialization/unordered_collections_save_imp.hpp>

#include <serialization/unordered_collections_load_imp.hpp>

#include <serialization/split_free.hpp>

file unordered_set.hpp

#include <boost/config.hpp>

#include <unordered_set>

#include <serialization/unordered_collections_save_imp.hpp>

#include <serialization/unordered_collections_load_imp.hpp>

#include <serialization/split_free.hpp>

file utf8_codecvt_facet.cpp

#include <boost/config.hpp>

#include <boost/detail/utf8_codecvt_facet.ipp>

file utf8_codecvt_facet.hpp

file utility.hpp

#include <utility>

#include <boost/config.hpp>

#include <boost/type_traits/remove_const.hpp>

#include <serialization/nvp.hpp>

#include <serialization/is_bitwise_serializable.hpp>

#include <boost/mpl/and.hpp>

file valarray.hpp

#include <valarray>

#include <boost/config.hpp>

#include <serialization/split_free.hpp>

#include <serialization/array.hpp>

#include <serialization/collection_size_type.hpp>

#include <serialization/detail/get_data.hpp>

#include <serialization/collection_traits.hpp>

Defines

STD

file variant.hpp

#include <boost/mpl/front.hpp>

#include <boost/mpl/pop_front.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/identity.hpp>

#include <boost/mpl/size.hpp>

#include <boost/mpl/empty.hpp>

#include <serialization/throw_exception.hpp>

#include <boost/variant.hpp>

#include <archive/archive_exception.hpp>

#include <serialization/split_free.hpp>

#include <serialization/serialization.hpp>

#include <serialization/nvp.hpp>

file vector.hpp

#include <vector>

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <serialization/collections_save_imp.hpp>

#include <serialization/collections_load_imp.hpp>

#include <serialization/split_free.hpp>

#include <serialization/array.hpp>

#include <serialization/detail/get_data.hpp>

#include <boost/mpl/bool.hpp>

#include <serialization/collection_traits.hpp>

Defines

I3_SERIALIZATION_VECTOR_VERSION

file vector_135.hpp

#include <serialization/vector.hpp>

Defines

I3_SERIALIZATION_VECTOR_VERSIONED(V)

file version.hpp

#include <boost/config.hpp>

#include <boost/mpl/assert.hpp>

#include <boost/mpl/int.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/identity.hpp>

#include <boost/mpl/integral_c_tag.hpp>

#include <boost/type_traits/is_base_and_derived.hpp>

#include <boost/mpl/less.hpp>

#include <boost/mpl/comparison.hpp>

Defines

I3_CLASS_VERSION(T, N)

file void_cast.cpp

#include <boost/assert.hpp>

#include <cstddef>

#include <set>

#include <functional>

#include <algorithm>

#include <serialization/singleton.hpp>

#include <serialization/extended_type_info.hpp>

#include <serialization/void_cast.hpp>

Defines

I3_SERIALIZATION_SOURCE

file void_cast.hpp

#include <cstddef>

#include <boost/config.hpp>

#include <boost/noncopyable.hpp>

#include <serialization/smart_cast.hpp>

#include <serialization/singleton.hpp>

#include <serialization/force_include.hpp>

#include <serialization/type_info_implementation.hpp>

#include <serialization/extended_type_info.hpp>

#include <boost/type_traits/aligned_storage.hpp>

#include <serialization/void_cast_fwd.hpp>

#include <serialization/config.hpp>

#include <boost/config/abi_prefix.hpp>

#include <boost/config/abi_suffix.hpp>

file void_cast_fwd.hpp

#include <cstddef>

#include <serialization/force_include.hpp>

file wchar_from_mb.hpp

#include <boost/assert.hpp>

#include <cctype>

#include <cstddef>

#include <cstdlib>

#include <boost/config.hpp>

#include <serialization/throw_exception.hpp>

#include <serialization/pfto.hpp>

#include <boost/iterator/iterator_adaptor.hpp>

#include <archive/iterators/dataflow_exception.hpp>

file wcslen.hpp

#include <cstddef>

#include <boost/config.hpp>

#include <cwchar>

file weak_ptr.hpp

#include <boost/weak_ptr.hpp>

#include <serialization/shared_ptr.hpp>

#include <memory>

file wrapper.hpp

#include <serialization/traits.hpp>

#include <boost/type_traits/is_base_and_derived.hpp>

#include <boost/mpl/eval_if.hpp>

#include <boost/mpl/bool.hpp>

Defines

I3_CLASS_IS_WRAPPER(T)

file xml_archive_exception.cpp

#include <exception>

#include <boost/assert.hpp>

#include <string>

#include <archive/xml_archive_exception.hpp>

Defines

I3_ARCHIVE_SOURCE

file xml_archive_exception.hpp

#include <exception>

#include <boost/assert.hpp>

#include <boost/config.hpp>

#include <boost/preprocessor/empty.hpp>

#include <archive/detail/decl.hpp>

#include <archive/archive_exception.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file xml_escape.hpp

#include <boost/assert.hpp>

#include <serialization/pfto.hpp>

#include <archive/iterators/escape.hpp>

file xml_grammar.cpp

#include <archive/impl/basic_xml_grammar.hpp>

#include <boost/config.hpp>

#include “basic_xml_grammar.ipp”

#include <istream>

#include <algorithm>

#include <boost/spirit/include/classic_operators.hpp>

#include <boost/spirit/include/classic_actions.hpp>

#include <boost/spirit/include/classic_numerics.hpp>

#include <boost/function.hpp>

#include <serialization/pfto.hpp>

#include <boost/io/ios_state.hpp>

#include <serialization/throw_exception.hpp>

#include <archive/impl/basic_xml_grammar.hpp>

#include <archive/xml_archive_exception.hpp>

#include <archive/basic_xml_archive.hpp>

#include <archive/iterators/xml_unescape.hpp>

Defines

I3_ARCHIVE_SOURCE

file xml_iarchive.cpp

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <archive/xml_iarchive.hpp>

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/impl/archive_serializer_map.ipp>

#include <archive/impl/basic_xml_iarchive.ipp>

#include <archive/impl/xml_iarchive_impl.ipp>

Defines

I3_ARCHIVE_SOURCE

file xml_iarchive.hpp

#include <istream>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/basic_text_iprimitive.hpp>

#include <archive/basic_xml_iarchive.hpp>

#include <archive/detail/register_archive.hpp>

#include <serialization/item_version_type.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file xml_oarchive.cpp

#include <archive/xml_oarchive.hpp>

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/impl/archive_serializer_map.ipp>

#include <archive/impl/basic_xml_oarchive.ipp>

#include <archive/impl/xml_oarchive_impl.ipp>

Defines

I3_ARCHIVE_SOURCE

file xml_oarchive.hpp

#include <ostream>

#include <cstddef>

#include <boost/config.hpp>

#include <archive/detail/auto_link_archive.hpp>

#include <archive/basic_text_oprimitive.hpp>

#include <archive/basic_xml_oarchive.hpp>

#include <archive/detail/register_archive.hpp>

#include <serialization/item_version_type.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file xml_unescape.hpp

#include <boost/assert.hpp>

#include <serialization/throw_exception.hpp>

#include <serialization/pfto.hpp>

#include <archive/iterators/unescape.hpp>

#include <archive/iterators/dataflow_exception.hpp>

file xml_unescape_exception.hpp

#include <boost/config.hpp>

#include <exception>

#include <boost/assert.hpp>

file xml_wgrammar.cpp

#include <boost/config.hpp>

#include <archive/impl/basic_xml_grammar.hpp>

#include “basic_xml_grammar.ipp”

Defines

I3_WARCHIVE_SOURCE

file xml_wiarchive.cpp

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <archive/xml_wiarchive.hpp>

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/impl/archive_serializer_map.ipp>

#include <archive/impl/basic_xml_iarchive.ipp>

#include <archive/impl/xml_wiarchive_impl.ipp>

Defines

I3_WARCHIVE_SOURCE

file xml_wiarchive.hpp

#include <boost/config.hpp>

#include <istream>

#include <archive/detail/auto_link_warchive.hpp>

#include <archive/basic_text_iprimitive.hpp>

#include <archive/basic_xml_iarchive.hpp>

#include <archive/detail/register_archive.hpp>

#include <serialization/item_version_type.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

file xml_woarchive.cpp

#include <boost/config.hpp>

#include <archive/xml_woarchive.hpp>

#include <archive/detail/archive_serializer_map.hpp>

#include <archive/impl/archive_serializer_map.ipp>

#include <archive/impl/basic_xml_oarchive.ipp>

#include <archive/impl/xml_woarchive_impl.ipp>

Defines

I3_WARCHIVE_SOURCE

file xml_woarchive.hpp

#include <boost/config.hpp>

#include <cstddef>

#include <ostream>

#include <archive/detail/auto_link_warchive.hpp>

#include <archive/basic_text_oprimitive.hpp>

#include <archive/basic_xml_oarchive.hpp>

#include <archive/detail/register_archive.hpp>

#include <serialization/item_version_type.hpp>

#include <archive/detail/abi_prefix.hpp>

#include <archive/detail/abi_suffix.hpp>

dir archive

dir archive

dir detail

dir detail

dir icetray

dir impl

dir iterators

dir private

dir public

dir serialization

dir serialization

dir serialization