serialization.hh File Reference

#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/preprocessor/comma_if.hpp>
#include <boost/preprocessor/facilities/is_empty.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/utility.hpp>
#include <boost/version.hpp>
#include <hpp/util/config.hh>
#include <hpp/util/serialization-fwd.hh>

Include dependency graph for serialization.hh:

Go to the source code of this file.

Classes
class	hpp::serialization::holder_base
class	hpp::serialization::holder< T >
class	hpp::serialization::archive_ptr_holder
class	hpp::serialization::archive_tpl< archive_base, parent_classes >

Namespaces
namespace	hpp
namespace	hpp::serialization

Macros
#define	_HPP_SERIALIZATION_SPLIT_IMPLEMENT(type, archive, arg)
#define	_HPP_SERIALIZATION_IMPLEMENT(type, archive, arg)
#define	HPP_SERIALIZATION_SPLIT_IMPLEMENT(type)
#define	HPP_SERIALIZATION_IMPLEMENT(type)
#define	HPP_SERIALIZATION_FREE_IMPLEMENT(type)
#define	HPP_SERIALIZATION_SPLIT_FREE_IMPLEMENT(type)

Typedefs
typedef archive_tpl< boost::archive::binary_iarchive >	hpp::serialization::binary_iarchive
typedef archive_tpl< boost::archive::binary_oarchive >	hpp::serialization::binary_oarchive
typedef archive_tpl< boost::archive::xml_iarchive >	hpp::serialization::xml_iarchive
typedef archive_tpl< boost::archive::xml_oarchive >	hpp::serialization::xml_oarchive
typedef archive_tpl< boost::archive::text_iarchive >	hpp::serialization::text_iarchive
typedef archive_tpl< boost::archive::text_oarchive >	hpp::serialization::text_oarchive

Functions
template<typename Archive >
archive_ptr_holder &	hpp::serialization::cast (Archive &ar)
template<typename Archive >
archive_ptr_holder *	hpp::serialization::cast (Archive *ar)

Macro Definition Documentation

_HPP_SERIALIZATION_IMPLEMENT

#define _HPP_SERIALIZATION_IMPLEMENT	(		type,
			archive,
			arg
	)

Value:

  template void type serialize<archive##_iarchive>(               \
      archive##_iarchive & ar,                                    \
      arg BOOST_PP_COMMA_IF(BOOST_PP_NOT(BOOST_PP_IS_EMPTY(arg))) \
          const unsigned int ver);                                \
  template void type serialize<archive##_oarchive>(               \
      archive##_oarchive & ar,                                    \
      arg BOOST_PP_COMMA_IF(BOOST_PP_NOT(BOOST_PP_IS_EMPTY(arg))) \
          const unsigned int ver)

_HPP_SERIALIZATION_SPLIT_IMPLEMENT

#define _HPP_SERIALIZATION_SPLIT_IMPLEMENT	(		type,
			archive,
			arg
	)

Value:

  template void type load<archive##_iarchive>(                        \
      archive##_iarchive & ar,                                        \
      arg BOOST_PP_COMMA_IF(BOOST_PP_NOT(BOOST_PP_IS_EMPTY(arg)))     \
          const unsigned int ver);                                    \
  template void type save<archive##_oarchive>(                        \
      archive##_oarchive & ar,                                        \
      BOOST_PP_IF(BOOST_PP_IS_EMPTY(arg), , const)                    \
          arg BOOST_PP_COMMA_IF(BOOST_PP_NOT(BOOST_PP_IS_EMPTY(arg))) \
              const unsigned int ver)                                 \
      BOOST_PP_IF(BOOST_PP_IS_EMPTY(arg), const, )

HPP_SERIALIZATION_FREE_IMPLEMENT

#define HPP_SERIALIZATION_FREE_IMPLEMENT

(

type

)

Value:

  namespace boost {                                         \
  namespace serialization {                                 \
  _HPP_SERIALIZATION_IMPLEMENT(, archive::xml, type& t);    \
  _HPP_SERIALIZATION_IMPLEMENT(, archive::text, type& t);   \
  _HPP_SERIALIZATION_IMPLEMENT(, archive::binary, type& t); \
  }                                                         \
  }

HPP_SERIALIZATION_IMPLEMENT

#define HPP_SERIALIZATION_IMPLEMENT

(

type

)

Value:

  _HPP_SERIALIZATION_IMPLEMENT(type::, boost::archive::xml, );  \
  _HPP_SERIALIZATION_IMPLEMENT(type::, boost::archive::text, ); \
  _HPP_SERIALIZATION_IMPLEMENT(type::, boost::archive::binary, )

HPP_SERIALIZATION_SPLIT_FREE_IMPLEMENT

#define HPP_SERIALIZATION_SPLIT_FREE_IMPLEMENT

(

type

)

Value:

  namespace boost {                                                  \
  namespace serialization {                                          \
  template <class Archive>                                           \
  void serialize(Archive& ar, type& t, const unsigned int version) { \
    split_free(ar, t, version);                                      \
  }                                                                  \
  _HPP_SERIALIZATION_IMPLEMENT(, archive::xml, type& t);             \
  _HPP_SERIALIZATION_IMPLEMENT(, archive::text, type& t);            \
  _HPP_SERIALIZATION_IMPLEMENT(, archive::binary, type& t);          \
  }                                                                  \
  }

HPP_SERIALIZATION_SPLIT_IMPLEMENT

#define HPP_SERIALIZATION_SPLIT_IMPLEMENT

(

type

)

Value:

  _HPP_SERIALIZATION_SPLIT_IMPLEMENT(type::, boost::archive::xml, );  \
  _HPP_SERIALIZATION_SPLIT_IMPLEMENT(type::, boost::archive::text, ); \
  _HPP_SERIALIZATION_SPLIT_IMPLEMENT(type::, boost::archive::binary, )