1#ifndef BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP
2#define BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP
3
4// MS compatible compilers support #pragma once
5#if defined(_MSC_VER)
6# pragma once
7#endif
8
9/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
10// shared_ptr_helper.hpp: serialization for boost shared pointer
11
12// (C) Copyright 2004-2009 Robert Ramey, Martin Ecker and Takatoshi Kondo
13// Use, modification and distribution is subject to the Boost Software
14// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
15// http://www.boost.org/LICENSE_1_0.txt)
16
17// See http://www.boost.org for updates, documentation, and revision history.
18
19#include <map>
20#include <list>
21#include <utility>
22#include <cstddef> // NULL
23
24#include <boost/config.hpp>
25#include <boost/shared_ptr.hpp>
26#include <boost/type_traits/is_polymorphic.hpp>
27#include <boost/mpl/if.hpp>
28
29#include <boost/serialization/singleton.hpp>
30#include <boost/serialization/extended_type_info.hpp>
31#include <boost/serialization/throw_exception.hpp>
32#include <boost/serialization/type_info_implementation.hpp>
33#include <boost/archive/archive_exception.hpp>
34
35namespace boost_132 {
36 template<class T> class shared_ptr;
37}
38namespace boost {
39namespace serialization {
40
41#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
42template<class Archive, template<class U> class SPT >
43void load(
44 Archive & ar,
45 SPT< class U > &t,
46 const unsigned int file_version
47);
48#endif
49
50/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
51// a common class for holding various types of shared pointers
52
53template<template<class T> class SPT>
54class shared_ptr_helper {
55 typedef std::map<
56 const void *, // address of object
57 SPT<const void> // address shared ptr to single instance
58 > object_shared_pointer_map;
59
60 // list of shared_pointers create accessible by raw pointer. This
61 // is used to "match up" shared pointers loaded at different
62 // points in the archive. Note, we delay construction until
63 // it is actually used since this is by default included as
64 // a "mix-in" even if shared_ptr isn't used.
65 object_shared_pointer_map * m_o_sp;
66
67 struct null_deleter {
68 void operator()(void const *) const {}
69 };
70
71#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) \
72|| defined(BOOST_MSVC) \
73|| defined(__SUNPRO_CC)
74public:
75#else
76 template<class Archive, class U>
77 friend void boost::serialization::load(
78 Archive & ar,
79 SPT< U > &t,
80 const unsigned int file_version
81 );
82#endif
83
84 #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
85 // list of loaded pointers. This is used to be sure that the pointers
86 // stay around long enough to be "matched" with other pointers loaded
87 // by the same archive. These are created with a "null_deleter" so that
88 // when this list is destroyed - the underlying raw pointers are not
89 // destroyed. This has to be done because the pointers are also held by
90 // new system which is disjoint from this set. This is implemented
91 // by a change in load_construct_data below. It makes this file suitable
92 // only for loading pointers into a 1.33 or later boost system.
93 std::list<boost_132::shared_ptr<const void> > * m_pointers_132;
94 void
95 append(const boost_132::shared_ptr<const void> & t){
96 if(NULL == m_pointers_132)
97 m_pointers_132 = new std::list<boost_132::shared_ptr<const void> >;
98 m_pointers_132->push_back(t);
99 }
100 #endif
101
102 struct non_polymorphic {
103 template<class U>
104 static const boost::serialization::extended_type_info *
105 get_object_type(U & ){
106 return & boost::serialization::singleton<
107 typename
108 boost::serialization::type_info_implementation< U >::type
109 >::get_const_instance();
110 }
111 };
112 struct polymorphic {
113 template<class U>
114 static const boost::serialization::extended_type_info *
115 get_object_type(U & u){
116 return boost::serialization::singleton<
117 typename
118 boost::serialization::type_info_implementation< U >::type
119 >::get_const_instance().get_derived_extended_type_info(u);
120 }
121 };
122
123public:
124 template<class T>
125 void reset(SPT< T > & s, T * t){
126 if(NULL == t){
127 s.reset();
128 return;
129 }
130 const boost::serialization::extended_type_info * this_type
131 = & boost::serialization::type_info_implementation< T >::type
132 ::get_const_instance();
133
134 // get pointer to the most derived object's eti. This is effectively
135 // the object type identifier
136 typedef typename mpl::if_<
137 is_polymorphic< T >,
138 polymorphic,
139 non_polymorphic
140 >::type type;
141
142 const boost::serialization::extended_type_info * true_type
143 = type::get_object_type(*t);
144
145 // note:if this exception is thrown, be sure that derived pointer
146 // is either registered or exported.
147 if(NULL == true_type)
148 boost::serialization::throw_exception(
149 e: boost::archive::archive_exception(
150 boost::archive::archive_exception::unregistered_class,
151 this_type->get_debug_info()
152 )
153 );
154 // get void pointer to the most derived type
155 // this uniquely identifies the object referred to
156 // oid = "object identifier"
157 const void * oid = void_downcast(
158 *true_type,
159 *this_type,
160 t
161 );
162 if(NULL == oid)
163 boost::serialization::throw_exception(
164 e: boost::archive::archive_exception(
165 boost::archive::archive_exception::unregistered_cast,
166 true_type->get_debug_info(),
167 this_type->get_debug_info()
168 )
169 );
170
171 // make tracking array if necessary
172 if(NULL == m_o_sp)
173 m_o_sp = new object_shared_pointer_map;
174
175 typename object_shared_pointer_map::iterator i = m_o_sp->find(oid);
176
177 // if it's a new object
178 if(i == m_o_sp->end()){
179 s.reset(t);
180 std::pair<typename object_shared_pointer_map::iterator, bool> result;
181 result = m_o_sp->insert(std::make_pair(oid, s));
182 BOOST_ASSERT(result.second);
183 }
184 // if the object has already been seen
185 else{
186 s = SPT<T>(i->second, t);
187 }
188 }
189
190 shared_ptr_helper() :
191 m_o_sp(NULL)
192 #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
193 , m_pointers_132(NULL)
194 #endif
195 {}
196 virtual ~shared_ptr_helper(){
197 if(NULL != m_o_sp)
198 delete m_o_sp;
199 #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
200 if(NULL != m_pointers_132)
201 delete m_pointers_132;
202 #endif
203 }
204};
205
206} // namespace serialization
207} // namespace boost
208
209#endif // BOOST_SERIALIZATION_SHARED_PTR_HELPER_HPP
210

source code of boost/libs/serialization/include/boost/serialization/shared_ptr_helper.hpp