1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
|
#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
|
Swift