#ifndef BOOST_ARCHIVE_SHARED_PTR_HELPER_HPP
#define BOOST_ARCHIVE_SHARED_PTR_HELPER_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
// shared_ptr_helper.hpp: serialization for boost shared pointern
// (C) Copyright 2004-2009 Robert Ramey, Martin Ecker and Takatoshi Kondo
// 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.
#include <set>
#include <list>
#include <utility>
#include <cstddef> // NULL
#include <boost/config.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/type_traits/is_polymorphic.hpp>
#include <boost/serialization/type_info_implementation.hpp>
#include <boost/serialization/shared_ptr_132.hpp>
#include <boost/serialization/throw_exception.hpp>
#include <boost/archive/archive_exception.hpp>
#include <boost/archive/detail/decl.hpp>
#include <boost/archive/detail/abi_prefix.hpp> // must be the last headern
namespace boost_132 {
template<class T> class shared_ptr;
}
namespace boost {
template<class T> class shared_ptr;
namespace serialization {
class extended_type_info;
template<class Archive, class T>
inline void load(
Archive & ar,
boost::shared_ptr< T > &t,
const unsigned int file_version
);
}
namespace archive{
namespace detail {
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// a common class for holding various types of shared pointers
class shared_ptr_helper {
struct collection_type_compare {
bool operator()(
const shared_ptr<const void> &lhs,
const shared_ptr<const void> &rhs
)const{
return lhs.get() < rhs.get();
}
};
typedef std::set<
boost::shared_ptr<const void>,
collection_type_compare
> collection_type;
typedef collection_type::const_iterator iterator_type;
// list of shared_pointers create accessable by raw pointer. This
// is used to "match up" shared pointers loaded at different
// points in the archive. Note, we delay construction until
// it is actually used since this is by default included as
// a "mix-in" even if shared_ptr isn't used.
collection_type * m_pointers;
struct null_deleter {
void operator()(void const *) const {}
};
struct void_deleter {
const boost::serialization::extended_type_info * m_eti;
void_deleter(const boost::serialization::extended_type_info *eti) :
m_eti(eti)
{}
void operator()(void *vp) const {
m_eti->destroy(vp);
}
};
#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
public:
#else
template<class Archive, class T>
friend inline void boost::serialization::load(
Archive & ar,
boost::shared_ptr< T > &t,
const unsigned int file_version
);
#endif
// #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
// list of loaded pointers. This is used to be sure that the pointers
// stay around long enough to be "matched" with other pointers loaded
// by the same archive. These are created with a "null_deleter" so that
// when this list is destroyed - the underlaying raw pointers are not
// destroyed. This has to be done because the pointers are also held by
// new system which is disjoint from this set. This is implemented
// by a change in load_construct_data below. It makes this file suitable
// only for loading pointers into a 1.33 or later boost system.
std::list<boost_132::shared_ptr<const void> > * m_pointers_132;
// #endif
// returns pointer to object and an indicator whether this is a
// new entry (true) or a previous one (false)
BOOST_ARCHIVE_DECL(shared_ptr<void>)
get_od(
const void * od,
const boost::serialization::extended_type_info * true_type,
const boost::serialization::extended_type_info * this_type
);
BOOST_ARCHIVE_DECL(void)
append(const boost::shared_ptr<const void> &);
template<class T>
struct non_polymorphic {
static const boost::serialization::extended_type_info *
get_object_identifier(T & t){
return & boost::serialization::singleton<
BOOST_DEDUCED_TYPENAME
boost::serialization::type_info_implementation< T >::type
>::get_const_instance();
}
};
template<class T>
struct polymorphic {
static const boost::serialization::extended_type_info *
get_object_identifier(T & t){
return boost::serialization::singleton<
BOOST_DEDUCED_TYPENAME
boost::serialization::type_info_implementation< T >::type
>::get_const_instance().get_derived_extended_type_info(t);
}
};
public:
template<class T>
void reset(shared_ptr< T > & s, T * t){
if(NULL == t){
s.reset();
return;
}
const boost::serialization::extended_type_info * this_type
= & boost::serialization::type_info_implementation< T >::type
::get_const_instance();
// get pointer to the most derived object. This is effectively
// the object identifern
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
is_polymorphic< T >,
mpl::identity<polymorphic< T > >,
mpl::identity<non_polymorphic< T > >
>::type type;
const boost::serialization::extended_type_info * true_type
= type::get_object_identifier(*t);
// note:if this exception is thrown, be sure that derived pointern
// is either registered or exported.
if(NULL == true_type)
boost::serialization::throw_exception(
archive_exception(
archive_exception::unregistered_class,
this_type->get_debug_info()
)
);
shared_ptr<void> r =
get_od(
static_cast<const void *>(t),
true_type,
this_type
);
if(!r){
s.reset(t);
const void * od = void_downcast(
*true_type,
*this_type,
static_cast<const void *>(t)
);
shared_ptr<const void> sp(s, od);
append(sp);
}
else{
s = shared_ptr< T >(
r,
static_cast<T *>(r.get())
);
}
}
// #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
BOOST_ARCHIVE_DECL(void)
append(const boost_132::shared_ptr<const void> & t);
// #endif
public:
BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
shared_ptr_helper();
BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
~shared_ptr_helper();
};
} // namespace detail
} // namespace archive
} // namespace boost
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
#endif // BOOST_ARCHIVE_SHARED_PTR_HELPER_HPP
Submit an article or tip