]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | #ifndef BOOST_ARCHIVE_BASIC_ARCHIVE_HPP |
2 | #define BOOST_ARCHIVE_BASIC_ARCHIVE_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 | // basic_archive.hpp: | |
11 | ||
12 | // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . | |
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 | #include <cstring> // count | |
19 | #include <boost/assert.hpp> | |
20 | #include <boost/config.hpp> | |
21 | #include <boost/cstdint.hpp> // size_t | |
22 | #include <boost/noncopyable.hpp> | |
23 | #include <boost/integer_traits.hpp> | |
24 | ||
25 | #include <boost/archive/detail/auto_link_archive.hpp> | |
26 | #include <boost/archive/detail/abi_prefix.hpp> // must be the last header | |
27 | ||
28 | namespace boost { | |
29 | namespace archive { | |
30 | ||
31 | #if defined(_MSC_VER) | |
32 | #pragma warning( push ) | |
33 | #pragma warning( disable : 4244 4267 ) | |
34 | #endif | |
35 | ||
36 | /* NOTE : Warning : Warning : Warning : Warning : Warning | |
37 | * Don't ever changes this. If you do, they previously created | |
38 | * binary archives won't be readable !!! | |
39 | */ | |
40 | class library_version_type { | |
41 | private: | |
42 | typedef uint_least16_t base_type; | |
43 | base_type t; | |
44 | public: | |
45 | library_version_type(): t(0) {}; | |
46 | explicit library_version_type(const unsigned int & t_) : t(t_){ | |
47 | BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max); | |
48 | } | |
49 | library_version_type(const library_version_type & t_) : | |
50 | t(t_.t) | |
51 | {} | |
52 | library_version_type & operator=(const library_version_type & rhs){ | |
53 | t = rhs.t; | |
54 | return *this; | |
55 | } | |
56 | // used for text output | |
57 | operator base_type () const { | |
58 | return t; | |
59 | } | |
60 | // used for text input | |
61 | operator base_type & (){ | |
62 | return t; | |
63 | } | |
64 | bool operator==(const library_version_type & rhs) const { | |
65 | return t == rhs.t; | |
66 | } | |
67 | bool operator<(const library_version_type & rhs) const { | |
68 | return t < rhs.t; | |
69 | } | |
70 | }; | |
71 | ||
72 | BOOST_ARCHIVE_DECL library_version_type | |
73 | BOOST_ARCHIVE_VERSION(); | |
74 | ||
75 | class version_type { | |
76 | private: | |
77 | typedef uint_least32_t base_type; | |
78 | base_type t; | |
79 | public: | |
80 | // should be private - but MPI fails if it's not!!! | |
81 | version_type(): t(0) {}; | |
82 | explicit version_type(const unsigned int & t_) : t(t_){ | |
83 | BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max); | |
84 | } | |
85 | version_type(const version_type & t_) : | |
86 | t(t_.t) | |
87 | {} | |
88 | version_type & operator=(const version_type & rhs){ | |
89 | t = rhs.t; | |
90 | return *this; | |
91 | } | |
92 | // used for text output | |
93 | operator base_type () const { | |
94 | return t; | |
95 | } | |
96 | // used for text intput | |
97 | operator base_type & (){ | |
98 | return t; | |
99 | } | |
100 | bool operator==(const version_type & rhs) const { | |
101 | return t == rhs.t; | |
102 | } | |
103 | bool operator<(const version_type & rhs) const { | |
104 | return t < rhs.t; | |
105 | } | |
106 | }; | |
107 | ||
108 | class class_id_type { | |
109 | private: | |
110 | typedef int_least16_t base_type; | |
111 | base_type t; | |
112 | public: | |
113 | // should be private - but then can't use BOOST_STRONG_TYPE below | |
114 | class_id_type() : t(0) {}; | |
115 | explicit class_id_type(const int t_) : t(t_){ | |
116 | BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max); | |
117 | } | |
118 | explicit class_id_type(const std::size_t t_) : t(t_){ | |
119 | // BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max); | |
120 | } | |
121 | class_id_type(const class_id_type & t_) : | |
122 | t(t_.t) | |
123 | {} | |
124 | class_id_type & operator=(const class_id_type & rhs){ | |
125 | t = rhs.t; | |
126 | return *this; | |
127 | } | |
128 | ||
129 | // used for text output | |
130 | operator int () const { | |
131 | return t; | |
132 | } | |
133 | // used for text input | |
134 | operator int_least16_t &() { | |
135 | return t; | |
136 | } | |
137 | bool operator==(const class_id_type & rhs) const { | |
138 | return t == rhs.t; | |
139 | } | |
140 | bool operator<(const class_id_type & rhs) const { | |
141 | return t < rhs.t; | |
142 | } | |
143 | }; | |
144 | ||
145 | #define NULL_POINTER_TAG boost::archive::class_id_type(-1) | |
146 | ||
147 | class object_id_type { | |
148 | private: | |
149 | typedef uint_least32_t base_type; | |
150 | base_type t; | |
151 | public: | |
152 | object_id_type(): t(0) {}; | |
153 | // note: presumes that size_t >= unsigned int. | |
154 | explicit object_id_type(const std::size_t & t_) : t(t_){ | |
155 | BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max); | |
156 | } | |
157 | object_id_type(const object_id_type & t_) : | |
158 | t(t_.t) | |
159 | {} | |
160 | object_id_type & operator=(const object_id_type & rhs){ | |
161 | t = rhs.t; | |
162 | return *this; | |
163 | } | |
164 | // used for text output | |
165 | operator uint_least32_t () const { | |
166 | return t; | |
167 | } | |
168 | // used for text input | |
169 | operator uint_least32_t & () { | |
170 | return t; | |
171 | } | |
172 | bool operator==(const object_id_type & rhs) const { | |
173 | return t == rhs.t; | |
174 | } | |
175 | bool operator<(const object_id_type & rhs) const { | |
176 | return t < rhs.t; | |
177 | } | |
178 | }; | |
179 | ||
180 | #if defined(_MSC_VER) | |
181 | #pragma warning( pop ) | |
182 | #endif | |
183 | ||
184 | struct tracking_type { | |
185 | bool t; | |
186 | explicit tracking_type(const bool t_ = false) | |
187 | : t(t_) | |
188 | {}; | |
189 | tracking_type(const tracking_type & t_) | |
190 | : t(t_.t) | |
191 | {} | |
192 | operator bool () const { | |
193 | return t; | |
194 | }; | |
195 | operator bool & () { | |
196 | return t; | |
197 | }; | |
198 | tracking_type & operator=(const bool t_){ | |
199 | t = t_; | |
200 | return *this; | |
201 | } | |
202 | bool operator==(const tracking_type & rhs) const { | |
203 | return t == rhs.t; | |
204 | } | |
205 | bool operator==(const bool & rhs) const { | |
206 | return t == rhs; | |
207 | } | |
208 | tracking_type & operator=(const tracking_type & rhs){ | |
209 | t = rhs.t; | |
210 | return *this; | |
211 | } | |
212 | }; | |
213 | ||
214 | struct class_name_type : | |
215 | private boost::noncopyable | |
216 | { | |
217 | char *t; | |
218 | operator const char * & () const { | |
219 | return const_cast<const char * &>(t); | |
220 | } | |
221 | operator char * () { | |
222 | return t; | |
223 | } | |
224 | std::size_t size() const { | |
225 | return std::strlen(t); | |
226 | } | |
227 | explicit class_name_type(const char *key_) | |
228 | : t(const_cast<char *>(key_)){} | |
229 | explicit class_name_type(char *key_) | |
230 | : t(key_){} | |
231 | class_name_type & operator=(const class_name_type & rhs){ | |
232 | t = rhs.t; | |
233 | return *this; | |
234 | } | |
235 | }; | |
236 | ||
237 | enum archive_flags { | |
238 | no_header = 1, // suppress archive header info | |
239 | no_codecvt = 2, // suppress alteration of codecvt facet | |
240 | no_xml_tag_checking = 4, // suppress checking of xml tags | |
241 | no_tracking = 8, // suppress ALL tracking | |
242 | flags_last = 8 | |
243 | }; | |
244 | ||
245 | BOOST_ARCHIVE_DECL const char * | |
246 | BOOST_ARCHIVE_SIGNATURE(); | |
247 | ||
248 | /* NOTE : Warning : Warning : Warning : Warning : Warning | |
249 | * If any of these are changed to different sized types, | |
250 | * binary_iarchive won't be able to read older archives | |
251 | * unless you rev the library version and include conditional | |
252 | * code based on the library version. There is nothing | |
253 | * inherently wrong in doing this - but you have to be super | |
254 | * careful because it's easy to get wrong and start breaking | |
255 | * old archives !!! | |
256 | */ | |
257 | ||
258 | #define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D) \ | |
259 | class D : public T { \ | |
260 | public: \ | |
261 | explicit D(const T tt) : T(tt){} \ | |
262 | }; \ | |
263 | /**/ | |
264 | ||
265 | BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_reference_type) | |
266 | BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_optional_type) | |
267 | BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type) | |
268 | ||
269 | }// namespace archive | |
270 | }// namespace boost | |
271 | ||
272 | #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas | |
273 | ||
274 | #include <boost/serialization/level.hpp> | |
275 | ||
276 | // set implementation level to primitive for all types | |
277 | // used internally by the serialization library | |
278 | ||
279 | BOOST_CLASS_IMPLEMENTATION(boost::archive::library_version_type, primitive_type) | |
280 | BOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type) | |
281 | BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type) | |
282 | BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type) | |
283 | BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_optional_type, primitive_type) | |
284 | BOOST_CLASS_IMPLEMENTATION(boost::archive::class_name_type, primitive_type) | |
285 | BOOST_CLASS_IMPLEMENTATION(boost::archive::object_id_type, primitive_type) | |
286 | BOOST_CLASS_IMPLEMENTATION(boost::archive::object_reference_type, primitive_type) | |
287 | BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type) | |
288 | ||
289 | #include <boost/serialization/is_bitwise_serializable.hpp> | |
290 | ||
291 | // set types used internally by the serialization library | |
292 | // to be bitwise serializable | |
293 | ||
294 | BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::library_version_type) | |
295 | BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::version_type) | |
296 | BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type) | |
297 | BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type) | |
298 | BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_optional_type) | |
299 | BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_name_type) | |
300 | BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_id_type) | |
301 | BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_reference_type) | |
302 | BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::tracking_type) | |
303 | ||
304 | #endif //BOOST_ARCHIVE_BASIC_ARCHIVE_HPP |