serialization C++ API Reference

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

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
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>
template<class T>
struct apply : public icecube::serialization::is_bitwise_serializable<T>
template<class T>
struct apply : public icecube::serialization::is_bitwise_serializable<T>
template<class T>
struct apply : public icecube::serialization::is_bitwise_serializable<T>
template<class Archive, class Container>
struct archive_input_map

Public Functions

inline void operator()(Archive &ar, Container &s, const unsigned int v)
template<class Archive, class Container>
struct archive_input_multimap

Public Functions

inline void operator()(Archive &ar, Container &s, const unsigned int v)
template<class Archive, class Container>
struct archive_input_multiset

Public Functions

inline void operator()(Archive &ar, Container &s, const unsigned int v)
template<class Archive, class Container>
struct archive_input_seq

Public Functions

inline void operator()(Archive &ar, Container &s, const unsigned int v)
template<class Archive, class Container>
struct archive_input_set

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

Public Functions

inline virtual char const *what() const noexcept
class base64_exception : public std::exception

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>

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>

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

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>

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

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

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

Public Functions

inline basic_serializer_arg(const serialization::extended_type_info &eti)
template<typename Ch, class Tr>
class basic_streambuf_locale_saver : private noncopyable

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>

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

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>

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

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

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>

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>

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>

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>

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>

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>

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>

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>

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>

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

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>

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>

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

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

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

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

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

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>

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

Public Types

typedef CharType result_type

Public Functions

inline CharType operator()(CharType t) const
template<class T>
struct guid_defined : public false_
template<typename T>
struct guid_impl

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

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>

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

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

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>
template<class T>
struct is_bitwise_serializable : public boost::is_arithmetic<T>

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

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>

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

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

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

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>

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

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>

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

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

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>

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

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>

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>

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>

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>

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

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

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

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>

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

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

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

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

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

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

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

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

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

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>

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

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

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>

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

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

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
struct use_array_optimization
struct use_array_optimization
struct use_array_optimization
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

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

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

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>
file archive_serializer_map.hpp
#include <boost/config.hpp>
file array.hpp
#include <boost/config.hpp>
#include <iostream>
#include <cstddef>
#include <array>
#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 <boost/config/auto_link.hpp>

Defines

I3_LIB_NAME
file auto_link_warchive.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 <boost/iterator/transform_iterator.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>
file basic_archive.cpp

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>

Defines

NULL_POINTER_TAG
I3_ARCHIVE_STRONG_TYPEDEF(T, D)
file basic_archive_impl.hpp
#include <set>
file basic_binary_iarchive.hpp
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/integer_traits.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 <boost/integer.hpp>
#include <boost/integer_traits.hpp>
#include <boost/mpl/placeholders.hpp>
file basic_binary_oarchive.hpp
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/integer.hpp>
#include <boost/integer_traits.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 <boost/mpl/placeholders.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>

Defines

I3_ARCHIVE_SOURCE
I3_SERIALIZATION_SOURCE
file basic_iarchive.hpp
#include <boost/config.hpp>
#include <boost/noncopyable.hpp>
file basic_iserializer.cpp
#include <cstddef>

Defines

I3_ARCHIVE_SOURCE
file basic_iserializer.hpp
#include <cstdlib>
#include <boost/config.hpp>
file basic_oarchive.cpp
#include <boost/config.hpp>
#include <boost/assert.hpp>
#include <set>
#include <cstddef>
#include <boost/limits.hpp>

Defines

I3_ARCHIVE_SOURCE
I3_SERIALIZATION_SOURCE
file basic_oarchive.hpp
#include <cstddef>
#include <boost/config.hpp>
#include <boost/noncopyable.hpp>
file basic_oserializer.cpp
#include <cstddef>

Defines

I3_ARCHIVE_SOURCE
file basic_oserializer.hpp
#include <cstddef>
#include <boost/config.hpp>
#include <boost/noncopyable.hpp>
file basic_pointer_iserializer.cpp

Defines

I3_ARCHIVE_SOURCE
file basic_pointer_iserializer.hpp
#include <boost/config.hpp>
#include <boost/noncopyable.hpp>
file basic_pointer_oserializer.cpp

Defines

I3_ARCHIVE_SOURCE
file basic_pointer_oserializer.hpp
#include <boost/config.hpp>
#include <boost/noncopyable.hpp>
file basic_serializer.hpp
#include <boost/assert.hpp>
#include <cstddef>
#include <boost/noncopyable.hpp>
#include <boost/config.hpp>
file basic_serializer_map.cpp
#include <set>
#include <utility>

Defines

I3_ARCHIVE_SOURCE
I3_SERIALIZATION_SOURCE
file basic_serializer_map.hpp
#include <set>
#include <boost/config.hpp>
#include <boost/noncopyable.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 <boost/detail/workaround.hpp>
file basic_text_iprimitive.cpp
#include <istream>
#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>
file basic_text_oarchive.hpp
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
file basic_text_oprimitive.cpp
#include <ostream>
#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>
file basic_text_wiprimitive.cpp
#include <boost/config.hpp>
#include <istream>
#include <archive/impl/basic_text_iprimitive.ipp>

Defines

I3_WARCHIVE_SOURCE
file basic_text_woprimitive.cpp
#include <boost/config.hpp>
#include <ostream>
#include <archive/impl/basic_text_oprimitive.ipp>

Defines

I3_WARCHIVE_SOURCE
file basic_xml_archive.cpp

Defines

I3_ARCHIVE_SOURCE
file basic_xml_archive.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>
file basic_xml_iarchive.hpp
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/mpl/assert.hpp>
file basic_xml_oarchive.hpp
#include <boost/config.hpp>
#include <boost/mpl/assert.hpp>
file binary_from_base64.hpp
#include <boost/assert.hpp>
#include <boost/static_assert.hpp>
#include <boost/iterator/transform_iterator.hpp>
file binary_iarchive.cpp
#include <istream>
#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>
file binary_iarchive_impl.hpp
#include <istream>
file binary_oarchive.cpp
#include <ostream>
#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>
file binary_oarchive_impl.hpp
#include <ostream>
#include <boost/config.hpp>
file binary_object.hpp
#include <boost/assert.hpp>
#include <cstddef>
#include <boost/config.hpp>
#include <boost/preprocessor/stringize.hpp>
file binary_wiarchive.cpp
#include <boost/config.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>
file binary_woarchive.cpp
#include <boost/config.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>
file bitset.hpp
#include <bitset>
#include <cstddef>
#include <cstdint>
#include <boost/config.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>
file codecvt_null.cpp

Defines

I3_WARCHIVE_SOURCE
file codecvt_null.hpp
#include <locale>
#include <cstddef>
#include <cwchar>
#include <boost/config.hpp>
file collection_size_type.hpp
#include <cstddef>
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>

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>
file collections_save_imp.hpp
#include <boost/config.hpp>
file common_iarchive.hpp
#include <boost/config.hpp>
file common_oarchive.hpp
#include <boost/config.hpp>
file complex.hpp
#include <complex>
#include <boost/config.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>
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 <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>
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 <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>

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

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

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 <boost/type_traits/is_polymorphic.hpp>
#include <boost/type_traits/remove_const.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>
file get_data.hpp
#include <vector>
#include <valarray>

Defines

STD
file hash_collections_load_imp.hpp
#include <boost/config.hpp>
file hash_collections_save_imp.hpp
#include <boost/config.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 <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>
file interface_oarchive.hpp
#include <cstddef>
#include <boost/cstdint.hpp>
#include <boost/mpl/bool.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 <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>
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 <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>

Defines

I3_CLASS_IMPLEMENTATION(T, E)
file level_enum.hpp
file list.hpp
#include <list>
#include <boost/config.hpp>
file map.hpp
#include <map>
#include <boost/config.hpp>
file mb_from_wchar.hpp
#include <boost/assert.hpp>
#include <cstddef>
#include <cstdlib>
#include <boost/config.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 <boost/preprocessor/stringize.hpp>

Defines

I3_SERIALIZATION_NVP(name)
I3_SERIALIZATION_BASE_OBJECT_NVP(name)
file optional.hpp
#include <boost/config.hpp>
#include <boost/optional.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 <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>
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>
file polymorphic_binary_oarchive.hpp
#include <boost/config.hpp>
file polymorphic_iarchive.cpp
#include <archive/impl/archive_serializer_map.ipp>

Defines

I3_ARCHIVE_SOURCE
file polymorphic_iarchive.hpp
#include <cstddef>
#include <climits>
#include <string>
#include <boost/config.hpp>
#include <boost/cstdint.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>
file polymorphic_oarchive.cpp
#include <archive/impl/archive_serializer_map.ipp>

Defines

I3_ARCHIVE_SOURCE
file polymorphic_oarchive.hpp
#include <cstddef>
#include <climits>
#include <string>
#include <boost/config.hpp>
#include <boost/cstdint.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>
file polymorphic_text_iarchive.hpp
#include <boost/config.hpp>
file polymorphic_text_oarchive.hpp
#include <boost/config.hpp>
file polymorphic_text_wiarchive.hpp
#include <boost/config.hpp>
file polymorphic_text_woarchive.hpp
#include <boost/config.hpp>
file polymorphic_xml_iarchive.hpp
#include <boost/config.hpp>
file polymorphic_xml_oarchive.hpp
#include <boost/config.hpp>
file polymorphic_xml_wiarchive.hpp
#include <boost/config.hpp>
file polymorphic_xml_woarchive.hpp
#include <boost/config.hpp>
file portable_binary_archive.cpp
#include <limits>
#include <archive/impl/archive_serializer_map.ipp>
file portable_binary_archive.hpp
#include <streambuf>
#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>

Defines

STD
file queue.hpp
#include <queue>
#include <boost/config.hpp>

Defines

STD
file register_archive.hpp

Defines

I3_SERIALIZATION_REGISTER_ARCHIVE(Archive)
file remove_whitespace.hpp
#include <boost/assert.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>
file serialization.hpp
#include <boost/config.hpp>
file set.hpp
#include <set>
#include <boost/config.hpp>
file shared_count_132.hpp
#include <boost/config.hpp>
#include <boost/checked_delete.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 <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 <boost/detail/workaround.hpp>
#include <algorithm>
#include <functional>
#include <typeinfo>
#include <iosfwd>
file shared_ptr_132.hpp
#include <boost/config.hpp>
#include <list>
#include <cstddef>

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>

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>
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>
file shared_ptr_nmt_132.hpp
#include <boost/assert.hpp>
#include <boost/checked_delete.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>
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>
file split_free.hpp
#include <boost/config.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.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>

Defines

I3_SERIALIZATION_SPLIT_MEMBER()
file stack.hpp
#include <stack>
#include <boost/config.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>
file strong_typedef.hpp
#include <boost/config.hpp>
#include <boost/operators.hpp>

Defines

I3_STRONG_TYPEDEF(T, D)
file text_iarchive.cpp
#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>
file text_oarchive.cpp
#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>
file text_wiarchive.cpp
#include <boost/config.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>
file text_woarchive.cpp
#include <boost/config.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>
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>

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>
file transform_width.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>

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>
file unordered_collections_load_imp.hpp
#include <boost/assert.hpp>
#include <cstddef>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
file unordered_collections_save_imp.hpp
#include <boost/config.hpp>
file unordered_map.hpp
#include <boost/config.hpp>
#include <unordered_map>
file unordered_set.hpp
#include <boost/config.hpp>
#include <unordered_set>
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 <boost/mpl/and.hpp>
file valarray.hpp
#include <valarray>
#include <boost/config.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 <boost/variant.hpp>
file vector.hpp
#include <vector>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/mpl/bool.hpp>

Defines

I3_SERIALIZATION_VECTOR_VERSION
file vector_135.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>

Defines

I3_SERIALIZATION_SOURCE
file void_cast.hpp
#include <cstddef>
#include <boost/config.hpp>
#include <boost/noncopyable.hpp>
#include <boost/type_traits/aligned_storage.hpp>
#include <boost/config/abi_prefix.hpp>
#include <boost/config/abi_suffix.hpp>
file void_cast_fwd.hpp
#include <cstddef>
file wchar_from_mb.hpp
#include <boost/assert.hpp>
#include <cctype>
#include <cstddef>
#include <cstdlib>
#include <boost/config.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
file wcslen.hpp
#include <cstddef>
#include <boost/config.hpp>
#include <cwchar>
file weak_ptr.hpp
#include <boost/weak_ptr.hpp>
#include <memory>
file wrapper.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>

Defines

I3_ARCHIVE_SOURCE
file xml_archive_exception.hpp
#include <exception>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/preprocessor/empty.hpp>
file xml_escape.hpp
#include <boost/assert.hpp>
file xml_grammar.cpp
#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/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>
file xml_oarchive.cpp
#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>
file xml_unescape.hpp
#include <boost/assert.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 “basic_xml_grammar.ipp”

Defines

I3_WARCHIVE_SOURCE
file xml_wiarchive.cpp
#include <boost/config.hpp>
#include <boost/detail/workaround.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>
file xml_woarchive.cpp
#include <boost/config.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>
dir archive
dir archive
dir detail
dir detail
dir icetray
dir impl
dir iterators
dir private
dir public
dir serialization
dir serialization
dir serialization