#ifndef BOOST_SERIALIZATION_EXPORT_HPP
#define BOOST_SERIALIZATION_EXPORT_HPP
// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// export.hpp: set traits of classes to be serialized
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org for updates, documentation, and revision history.
// implementation of class export functionality. This is an alternative to
// "forward declaration" method to provoke instantiation of derived classes
// that are to be serialized through pointers.
#include <utility>
#include <boost/config.hpp>
// if no archive headers have been included this is a no op
// this is to permit BOOST_EXPORT etc to be included in a
// file declaration header
#if ! defined(BOOST_ARCHIVE_BASIC_ARCHIVE_HPP)
#define BOOST_CLASS_EXPORT_GUID_ARCHIVE_LIST(T, K, ASEQ)
#else
#include <boost/static_assert.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/empty.hpp>
#include <boost/mpl/front.hpp>
#include <boost/mpl/pop_front.hpp>
#include <boost/mpl/void.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/archive/detail/known_archive_types.hpp>
#include <boost/serialization/force_include.hpp>
#include <boost/serialization/type_info_implementation.hpp>
#include <boost/serialization/is_abstract.hpp>
namespace boost {
namespace archive {
namespace detail {
// forward template declarations
class basic_pointer_iserializer;
template<class Archive, class T>
BOOST_DLLEXPORT const basic_pointer_iserializer &
instantiate_pointer_iserializer(Archive * ar, T *) BOOST_USED;
class basic_pointer_oserializer;
template<class Archive, class T>
BOOST_DLLEXPORT const basic_pointer_oserializer &
instantiate_pointer_oserializer(Archive * ar, T *) BOOST_USED;
namespace export_impl
{
struct nothing{
static void instantiate(){}
};
template<class Archive, class T>
struct archive {
struct i {
static void invoke(){
instantiate_pointer_iserializer(
static_cast<Archive *>(NULL),
static_cast<T *>(NULL)
);
}
};
struct o {
static void invoke(){
instantiate_pointer_oserializer(
static_cast<Archive *>(NULL),
static_cast<T *>(NULL)
);
}
};
static void instantiate(){
#if defined(__GNUC__) && (__GNUC__ >= 3)
BOOST_STATIC_ASSERT(
Archive::is_loading::value || Archive::is_saving::value
);
#endif
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
BOOST_DEDUCED_TYPENAME Archive::is_saving,
mpl::identity<o>,
// else
BOOST_DEDUCED_TYPENAME mpl::eval_if<
BOOST_DEDUCED_TYPENAME Archive::is_loading,
mpl::identity<i>,
// else
mpl::identity<nothing>
> >::type typex;
typex::invoke();
}
};
template<class ASeq, class T>
struct for_each_archive {
private:
typedef BOOST_DEDUCED_TYPENAME mpl::pop_front<ASeq>::type tail;
typedef BOOST_DEDUCED_TYPENAME mpl::front<ASeq>::type head;
public:
static void instantiate(){
archive<head, T>::instantiate();
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
mpl::empty<tail>,
mpl::identity<nothing>,
mpl::identity<for_each_archive<tail, T> >
>::type typex;
typex::instantiate();
}
};
} // namespace export_impl
// strictly conforming
template<class T, class ASeq>
struct export_generator {
export_generator(){
export_impl::for_each_archive<ASeq, T>::instantiate();
}
static const export_generator instance;
};
template<class T, class ASeq>
const export_generator<T, ASeq>
export_generator<T, ASeq>::instance;
// instantiation of this template creates a static object.
template<class T>
struct guid_initializer {
typedef BOOST_DEDUCED_TYPENAME boost::serialization::type_info_implementation<T>::type eti_type;
static void export_register(const char *key){
eti_type::export_register(key);
}
static const guid_initializer instance;
guid_initializer(const char *key = 0) BOOST_USED ;
};
template<class T>
guid_initializer<T>::guid_initializer(const char *key){
if(0 != key)
export_register(key);
}
template<class T>
const guid_initializer<T> guid_initializer<T>::instance;
// only gcc seems to be able to explicitly instantiate a static instance.
// but all can instantiate a function that refers to a static instance
// the following optimization - inhibiting explicit instantiation for abstract
// classes breaks msvc compliles
template<class T, class ASeq>
struct export_instance {
struct abstract {
static const export_generator<T, ASeq> *
invoke(){
return 0;
}
};
struct not_abstract {
static const export_generator<T, ASeq> *
invoke(){
return & export_generator<T, ASeq>::instance;
}
};
};
template<class T, class ASeq>
BOOST_DLLEXPORT
std::pair<const export_generator<T, ASeq> *, const guid_initializer<T> *>
export_instance_invoke() {
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
serialization::is_abstract<T>,
mpl::identity<BOOST_DEDUCED_TYPENAME export_instance<T, ASeq>::abstract>,
mpl::identity<BOOST_DEDUCED_TYPENAME export_instance<T, ASeq>::not_abstract>
>::type typex;
return std::pair<const export_generator<T, ASeq> *, const guid_initializer<T> *>(
typex::invoke(),
& guid_initializer<T>::instance
);
}
template<class T, class ASeq>
struct export_archives {
struct empty_archive_list {
static BOOST_DLLEXPORT
std::pair<const export_generator<T, ASeq> *, const guid_initializer<T> *>
invoke(){
return std::pair<const export_generator<T, ASeq> *,
const guid_initializer<T> *>(0, 0);
}
};
struct non_empty_archive_list {
static BOOST_DLLEXPORT
std::pair<const export_generator<T, ASeq> *, const guid_initializer<T> *>
invoke(){
return export_instance_invoke<T, ASeq>();
}
};
};
template<class T, class ASeq>
BOOST_DLLEXPORT
std::pair<const export_generator<T, ASeq> *, const guid_initializer<T> *>
export_archives_invoke(T &, ASeq &){
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
mpl::empty<ASeq>,
mpl::identity<BOOST_DEDUCED_TYPENAME export_archives<T, ASeq>::empty_archive_list>,
mpl::identity<BOOST_DEDUCED_TYPENAME export_archives<T, ASeq>::non_empty_archive_list>
>::type typex;
return typex::invoke();
}
} // namespace detail
} // namespace archive
} // namespace boost
#define BOOST_CLASS_EXPORT_GUID_ARCHIVE_LIST(T, K, ASEQ) \
namespace boost { \
namespace archive { \
namespace detail { \
template<> \
const guid_initializer< T > \
guid_initializer< T >::instance(K); \
template \
BOOST_DLLEXPORT \
std::pair<const export_generator<T, ASEQ> *, const guid_initializer< T > *> \
export_archives_invoke<T, ASEQ>(T &, ASEQ &); \
} } } \
/**/
#endif
// check for unnecessary export. T isn't polymorphic so there is no
// need to export it.
#define BOOST_CLASS_EXPORT_CHECK(T) \
BOOST_STATIC_WARNING( \
boost::serialization::type_info_implementation< T > \
::type::is_polymorphic::value \
); \
/**/
// the default list of archives types for which code id generated
#define BOOST_CLASS_EXPORT_GUID(T, K) \
BOOST_CLASS_EXPORT_GUID_ARCHIVE_LIST( \
T, \
K, \
boost::archive::detail::known_archive_types::type \
) \
/**/
// the default exportable class identifier is the class name
#define BOOST_CLASS_EXPORT_ARCHIVE_LIST(T, ASEQ) \
BOOST_CLASS_EXPORT_GUID_ARCHIVE_LIST(T, BOOST_PP_STRINGIZE(T), A)
// the default exportable class identifier is the class name
// the default list of archives types for which code id generated
// are the originally included with this serialization system
#define BOOST_CLASS_EXPORT(T) \
BOOST_CLASS_EXPORT_GUID_ARCHIVE_LIST( \
T, \
BOOST_PP_STRINGIZE(T), \
boost::archive::detail::known_archive_types::type \
) \
/**/
#endif // BOOST_SERIALIZATION_EXPORT_HPP