223 lines
7.2 KiB
C++
223 lines
7.2 KiB
C++
#ifndef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
|
|
#define BOOST_SERIALIZATION_SHARED_PTR_132_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.hpp: serialization for boost shared pointer
|
|
|
|
// (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.
|
|
|
|
// note: totally unadvised hack to gain access to private variables
|
|
// in shared_ptr and shared_count. Unfortunately its the only way to
|
|
// do this without changing shared_ptr and shared_count
|
|
// the best we can do is to detect a conflict here
|
|
#include <boost/config.hpp>
|
|
|
|
#include <list>
|
|
#include <cstddef> // NULL
|
|
|
|
#include <boost/serialization/assume_abstract.hpp>
|
|
#include <boost/serialization/split_free.hpp>
|
|
#include <boost/serialization/nvp.hpp>
|
|
#include <boost/serialization/tracking.hpp>
|
|
#include <boost/serialization/void_cast.hpp>
|
|
|
|
// mark base class as an (uncreatable) base class
|
|
#include <boost/serialization/detail/shared_ptr_132.hpp>
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// Maintain a couple of lists of loaded shared pointers of the old previous
|
|
// version (1.32)
|
|
|
|
namespace boost_132 {
|
|
namespace serialization {
|
|
namespace detail {
|
|
|
|
struct null_deleter {
|
|
void operator()(void const *) const {}
|
|
};
|
|
|
|
} // namespace detail
|
|
} // namespace serialization
|
|
} // namespace boost_132
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// sp_counted_base_impl serialization
|
|
|
|
namespace boost {
|
|
namespace serialization {
|
|
|
|
template<class Archive, class P, class D>
|
|
inline void serialize(
|
|
Archive & /* ar */,
|
|
boost_132::detail::sp_counted_base_impl<P, D> & /* t */,
|
|
const unsigned int /*file_version*/
|
|
){
|
|
// register the relationship between each derived class
|
|
// its polymorphic base
|
|
boost::serialization::void_cast_register<
|
|
boost_132::detail::sp_counted_base_impl<P, D>,
|
|
boost_132::detail::sp_counted_base
|
|
>(
|
|
static_cast<boost_132::detail::sp_counted_base_impl<P, D> *>(NULL),
|
|
static_cast<boost_132::detail::sp_counted_base *>(NULL)
|
|
);
|
|
}
|
|
|
|
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 BOOST_PFTO unsigned int /* file_version */
|
|
){
|
|
// variables used for construction
|
|
ar << boost::serialization::make_nvp("ptr", t->ptr);
|
|
}
|
|
|
|
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 /* file_version */
|
|
){
|
|
P ptr_;
|
|
ar >> boost::serialization::make_nvp("ptr", ptr_);
|
|
// ::new(t)boost_132::detail::sp_counted_base_impl<P, D>(ptr_, D());
|
|
// placement
|
|
// note: the original ::new... above is replaced by the one here. This one
|
|
// creates all new objects with a null_deleter so that after the archive
|
|
// is finished loading and the shared_ptrs are destroyed - the underlying
|
|
// raw pointers are NOT deleted. This is necessary as they are used by the
|
|
// new system as well.
|
|
::new(t)boost_132::detail::sp_counted_base_impl<
|
|
P,
|
|
boost_132::serialization::detail::null_deleter
|
|
>(
|
|
ptr_, boost_132::serialization::detail::null_deleter()
|
|
); // placement new
|
|
// compensate for that fact that a new shared count always is
|
|
// initialized with one. the add_ref_copy below will increment it
|
|
// every time its serialized so without this adjustment
|
|
// the use and weak counts will be off by one.
|
|
t->use_count_ = 0;
|
|
}
|
|
|
|
} // serialization
|
|
} // namespace boost
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// shared_count serialization
|
|
|
|
namespace boost {
|
|
namespace serialization {
|
|
|
|
template<class Archive>
|
|
inline void save(
|
|
Archive & ar,
|
|
const boost_132::detail::shared_count &t,
|
|
const unsigned int /* file_version */
|
|
){
|
|
ar << boost::serialization::make_nvp("pi", t.pi_);
|
|
}
|
|
|
|
template<class Archive>
|
|
inline void load(
|
|
Archive & ar,
|
|
boost_132::detail::shared_count &t,
|
|
const unsigned int /* file_version */
|
|
){
|
|
ar >> boost::serialization::make_nvp("pi", t.pi_);
|
|
if(NULL != t.pi_)
|
|
t.pi_->add_ref_copy();
|
|
}
|
|
|
|
} // serialization
|
|
} // namespace boost
|
|
|
|
BOOST_SERIALIZATION_SPLIT_FREE(boost_132::detail::shared_count)
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// implement serialization for shared_ptr< T >
|
|
|
|
namespace boost {
|
|
namespace serialization {
|
|
|
|
template<class Archive, class T>
|
|
inline void save(
|
|
Archive & ar,
|
|
const boost_132::shared_ptr< T > &t,
|
|
const unsigned int /* file_version */
|
|
){
|
|
// only the raw pointer has to be saved
|
|
// the ref count is maintained automatically as shared pointers are loaded
|
|
ar.register_type(static_cast<
|
|
boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter< T > > *
|
|
>(NULL));
|
|
ar << boost::serialization::make_nvp("px", t.px);
|
|
ar << boost::serialization::make_nvp("pn", t.pn);
|
|
}
|
|
|
|
template<class Archive, class T>
|
|
inline void load(
|
|
Archive & ar,
|
|
boost_132::shared_ptr< T > &t,
|
|
const unsigned int /* file_version */
|
|
){
|
|
// only the raw pointer has to be saved
|
|
// the ref count is maintained automatically as shared pointers are loaded
|
|
ar.register_type(static_cast<
|
|
boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter< T > > *
|
|
>(NULL));
|
|
ar >> boost::serialization::make_nvp("px", t.px);
|
|
ar >> boost::serialization::make_nvp("pn", t.pn);
|
|
}
|
|
|
|
template<class Archive, class T>
|
|
inline void serialize(
|
|
Archive & ar,
|
|
boost_132::shared_ptr< T > &t,
|
|
const unsigned int file_version
|
|
){
|
|
// correct shared_ptr serialization depends upon object tracking
|
|
// being used.
|
|
BOOST_STATIC_ASSERT(
|
|
boost::serialization::tracking_level< T >::value
|
|
!= boost::serialization::track_never
|
|
);
|
|
boost::serialization::split_free(ar, t, file_version);
|
|
}
|
|
|
|
} // serialization
|
|
} // namespace boost
|
|
|
|
// note: change below uses null_deleter
|
|
// This macro is used to export GUIDS for shared pointers to allow
|
|
// the serialization system to export them properly. David Tonge
|
|
#define BOOST_SHARED_POINTER_EXPORT_GUID(T, K) \
|
|
typedef boost_132::detail::sp_counted_base_impl< \
|
|
T *, \
|
|
boost::checked_deleter< T > \
|
|
> __shared_ptr_ ## T; \
|
|
BOOST_CLASS_EXPORT_GUID(__shared_ptr_ ## T, "__shared_ptr_" K) \
|
|
BOOST_CLASS_EXPORT_GUID(T, K) \
|
|
/**/
|
|
|
|
#define BOOST_SHARED_POINTER_EXPORT(T) \
|
|
BOOST_SHARED_POINTER_EXPORT_GUID( \
|
|
T, \
|
|
BOOST_PP_STRINGIZE(T) \
|
|
) \
|
|
/**/
|
|
|
|
#endif // BOOST_SERIALIZATION_SHARED_PTR_132_HPP
|