| #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 |