You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
222 lines
7.2 KiB
222 lines
7.2 KiB
#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
|
|
|