#include <boost/serialization/access.hpp>
#include <boost/serialization/export.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/remove_if.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/preprocessor/comma_if.hpp>
#include <boost/preprocessor/repeat.hpp>
#include <boost/preprocessor/inc.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/tuple/to_seq.hpp>
#include "Core/Mpl.h"
#include "Core/ObjectProps.h"
#include "Core/Archives.h"
#include "Core/Export.h"

Data Structures
struct	boost::serialization::access2< T >

class	boost::serialization::hrp< T >

struct	uLib::detail::Serializable

struct	uLib::detail::Serializable::serializable_trait< T >

struct	uLib::detail::Serializable::IsA< T >

struct	uLib::detail::Serializable::serialize_baseobject< ThisClass, Archive >

struct	uLib::Serializable

Namespaces
	boost

	boost::serialization

	uLib

	uLib::detail

Macros
#define	HRP(name) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)

#define	_AR_OP(r, data, elem) data&BOOST_SERIALIZATION_BASE_OBJECT_NVP(elem);

#define	NVP(data) BOOST_SERIALIZATION_NVP(data)

#define	ULIB_SERIALIZABLE(_Ob)

#define	ULIB_SERIALIZE(_Ob,...) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob)

#define	ULIB_SERIALIZE_DERIVED(_Ob,...) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob,__VA_ARGS__)

#define	ULIB_SERIALIZABLE_OBJECT(_Ob)

#define	ULIB_SERIALIZE_OBJECT(_Ob,...) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob,__VA_ARGS__)

#define	ULIB_SERIALIZE_OBJECT_PROPS(_Ob) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_PROPS(_Ob)

#define	AR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)

#define	HR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)

#define	ULIB_SERIALIZE_ACCESS

#define	ULIB_CLASS_EXPORT_KEY(_FullNamespaceClass) BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)

#define	ULIB_CLASS_EXPORT_OBJECT_KEY(_FullNamespaceClass)

#define	_SERIALIZE_IMPL_SEQ

#define	_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(_Base, _Derived) namespace boost{ template<> struct is_virtual_base_of<_Base,_Derived>: public boost::mpl::true_ {}; }

#define	_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP(r, data, elem) _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(elem,data)

#define	_ULIB_DETAIL_INTRUSIVE_AR_(name) ar & BOOST_SERIALIZATION_NVP(name);

#define	_ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(Class, Archive) template void Class::serialize(Archive &ar,const unsigned int);

#define	_ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP(r, data, elem) _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(data,elem);

#define	_ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT

#define	_ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob,...)

#define	_UNAR_OP(r, data, elem) ar&boost::serialization::make_nvp(BOOST_PP_STRINGIZE(elem),boost::serialization::base_object<elem>(ob));

#define	_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(Class, Archive) template void boost::serialization::serialize(Archive &ar, Class &ob, const unsigned int i);

#define	_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP(r, data, elem) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(data,elem)

#define	_ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob)

#define	_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob)

#define	_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob,...)

#define	_ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob)

#define	_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob,...)

#define	_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_PROPS(_Ob)

#define	_ULIB_DETAIL_UNINTRUSIVE_AR_(name) boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name),ob.name)

Functions
template<class T >
const hrp< T >	boost::serialization::make_hrp (const char *name, T &t)

Macro Definition Documentation

#define _AR_OP	(	r,
		data,
		elem
	)	data&BOOST_SERIALIZATION_BASE_OBJECT_NVP(elem);

#define _SERIALIZE_IMPL_SEQ

Value:

(uLib::Archive::text_iarchive) \
    (uLib::Archive::text_oarchive) \
    (uLib::Archive::hrt_iarchive)  \
    (uLib::Archive::hrt_oarchive)  \
    (uLib::Archive::xml_iarchive)  \
    (uLib::Archive::xml_oarchive)  \
    (uLib::Archive::log_archive)

#define _ULIB_DETAIL_INTRUSIVE_AR_ ( name ) ar & BOOST_SERIALIZATION_NVP(name);

#define _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT

Value:

typedef boost::mpl::bool_<true> serializable;                                                \
    typedef boost::mpl::remove_if< TypeList, IsUnSerializable >::type SerilizableTypeList;       \
    void PrintSerializableListId() { boost::mpl::for_each<SerilizableTypeList>(PrintTypeId()); } \
    template <class ArchiveT> void serialize(ArchiveT &ar,const unsigned int version);           \
    template <class ArchiveT> void serialize_parents(ArchiveT &ar,const unsigned int version);   \
    template <class ArchiveT> void save_override(ArchiveT &ar,const unsigned int version);

#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC	(	Class,
		Archive
	)	template void Class::serialize(Archive &ar,const unsigned int);

#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP	(	r,
		data,
		elem
	)	_ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(data,elem);

#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT	(	_Ob,
		...
	)

Value:

template <class ArchiveT> void _Ob::serialize(ArchiveT &ar, const unsigned int version) { \
    boost::serialization::void_cast_register<_Ob,_Ob::BaseClass>(static_cast<_Ob *>(NULL),static_cast<_Ob::BaseClass *>(NULL));   \
    _Ob::serialize_parents(ar,version); \
    _Ob::save_override(ar,version); }\
    template <class ArchiveT> void _Ob::serialize_parents(ArchiveT &ar, const unsigned int v) { \
    BOOST_PP_SEQ_FOR_EACH(_AR_OP,ar,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))); } \
    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ)\
    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP,_Ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
    ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
    namespace boost { \
    namespace serialization { \
    template<class ArchiveT> inline void load_construct_data(ArchiveT & ar, _Ob *o, const unsigned int file_version) \
    { ::new(o)_Ob(); o->init_parameters(); } }}\
    template <class ArchiveT> void _Ob::save_override(ArchiveT &ar, const unsigned int version)

#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE	(	_Base,
		_Derived
	)	namespace boost{ template<> struct is_virtual_base_of<_Base,_Derived>: public boost::mpl::true_ {}; }

Solving virtual class check problem

#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP	(	r,
		data,
		elem
	)	_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(elem,data)

#define _ULIB_DETAIL_UNINTRUSIVE_AR_ ( name ) boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name),ob.name)

#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE ( _Ob )

Value:

namespace boost { namespace serialization { \
    template <class ArchiveT> void serialize         (ArchiveT &ar, _Ob &ob, const unsigned int version); \
    template <class ArchiveT> void serialize_parents (ArchiveT &ar, _Ob &ob, const unsigned int version); \
    template <> struct access2< _Ob > { template <class ArchiveT> static void save_override (ArchiveT &ar, _Ob &ob, const unsigned int version); }; }}

#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT ( _Ob )

Value:

namespace boost { namespace serialization { \
    template <class ArchiveT> void serialize         (ArchiveT &ar, _Ob &ob, const unsigned int version); \
    template <class ArchiveT> void serialize_parents (ArchiveT &ar, _Ob &ob, const unsigned int version); \
    template <> struct access2< _Ob > { template <class ArchiveT> static void save_override (ArchiveT &ar, _Ob &ob, const unsigned int version); }; \
    template <class ArchiveT> void serialize         (ArchiveT &ar, class _Ob::ObjectProps &ob, const unsigned int version); \
    template <class ArchiveT> void save_override     (ArchiveT &ar, class _Ob::ObjectProps &ob, const unsigned int version); }}

#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE ( _Ob )

Value:

namespace boost { namespace serialization { \
    template <class ArchiveT> void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) {} \
    template <class ArchiveT> void serialize  (ArchiveT &ar, _Ob &ob, const unsigned int version) { \
    serialize_parents(ar,ob,version);  \
    access2< _Ob >::save_override(ar,ob,version); } }}\
    ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ)\
    template <class ArchiveT> void boost::serialization::access2< _Ob >::save_override(ArchiveT &ar, _Ob &ob, const unsigned int version)

#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED	(	_Ob,
		...
	)

Value:

namespace boost { namespace serialization { \
    template <class ArchiveT> void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) { \
    BOOST_PP_IF(BOOST_PP_VARIADIC_SIZE((__VA_ARGS__)),BOOST_PP_SEQ_FOR_EACH(_UNAR_OP,ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)));,) } \
    template <class ArchiveT> void serialize  (ArchiveT &ar, _Ob &ob, const unsigned int version) { \
    serialize_parents(ar,ob,version);  \
    access2< _Ob >::save_override    (ar,ob,version); } }}\
    ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ) \
    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP,_Ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
    template <class ArchiveT> void boost::serialization::access2< _Ob >::save_override(ArchiveT &ar, _Ob &ob, const unsigned int version)

#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC	(	Class,
		Archive
	)	template void boost::serialization::serialize(Archive &ar, Class &ob, const unsigned int i);

#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP	(	r,
		data,
		elem
	)	_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(data,elem)

#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT	(	_Ob,
		...
	)

Value:

namespace boost { namespace serialization { \
    template <class ArchiveT> void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) { \
    /* PP  serialize */ BOOST_PP_SEQ_FOR_EACH(_UNAR_OP,ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))); \
    /* MPL serialize */ /*uLib::mpl::for_each<_Ob::BaseList>(uLib::detail::Serializable::serialize_baseobject<_Ob,ArchiveT>(ob,ar) );*/ } \
    template<class ArchiveT> inline void load_construct_data(ArchiveT & ar, _Ob *ob, const unsigned int file_version) { \
    ::new(ob)_Ob(); uLib::detail::ObjectProps::initializer::init_object(ob); } \
    template <class ArchiveT> void serialize  (ArchiveT &ar, _Ob &ob, const unsigned int version) { \
    void_cast_register<_Ob,_Ob::BaseClass>(static_cast<_Ob *>(NULL),static_cast<_Ob::BaseClass *>(NULL)); /*fix*/  \
    serialize_parents(ar,ob,version);  \
    access2< _Ob >::save_override    (ar,ob,version); } }}\
    ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP,_Ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ)\
    template <class ArchiveT> void boost::serialization::access2< _Ob >::save_override(ArchiveT &ar, _Ob &ob, const unsigned int version)

#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_PROPS ( _Ob )

Value:

namespace boost { namespace serialization { \
    template <class ArchiveT> void serialize  (ArchiveT &ar, _Ob::ObjectProps &ob, const unsigned int version) { \
    save_override    (ar,ob,version); } }}\
    BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob::ObjectProps,_SERIALIZE_IMPL_SEQ)\
    ULIB_CLASS_EXPORT_IMPLEMENT(_Ob::ObjectProps) \
    ULIB_CLASS_EXPORT_IMPLEMENT(uLib::ObjectPropsImpl<_Ob>) \
    template <class ArchiveT> void boost::serialization::save_override(ArchiveT &ar, _Ob::ObjectProps &ob, const unsigned int version)

#define _UNAR_OP	(	r,
		data,
		elem
	)	ar&boost::serialization::make_nvp(BOOST_PP_STRINGIZE(elem),boost::serialization::base_object<elem>(ob));

#define AR ( _name ) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)

#define HR ( _name ) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)

#define HRP ( name ) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)

#define NVP ( data ) BOOST_SERIALIZATION_NVP(data)

#define ULIB_CLASS_EXPORT_KEY ( _FullNamespaceClass ) BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)

#define ULIB_CLASS_EXPORT_OBJECT_KEY ( _FullNamespaceClass )

Value:

BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)                      \
    BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass::ObjectProps)         \
    BOOST_CLASS_EXPORT_KEY(uLib::ObjectPropsImpl<_FullNamespaceClass>)

#define ULIB_SERIALIZABLE ( _Ob )

Value:

_ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob) \

ULIB_CLASS_EXPORT_KEY(_Ob)

_ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE

#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob)

Definition: Serializable.h:275

ULIB_CLASS_EXPORT_KEY

#define ULIB_CLASS_EXPORT_KEY(_FullNamespaceClass)

Definition: Serializable.h:190

#define ULIB_SERIALIZABLE_OBJECT ( _Ob )

Value: