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) && (_MSC_VER >= 1020)
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 
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:
library_version_type()45     library_version_type(): t(0) {};
library_version_type(const unsigned int & t_)46     explicit library_version_type(const unsigned int & t_) : t(t_){
47         BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
48     }
library_version_type(const library_version_type & t_)49     library_version_type(const library_version_type & t_) :
50         t(t_.t)
51     {}
operator =(const library_version_type & rhs)52     library_version_type & operator=(const library_version_type & rhs){
53         t = rhs.t;
54         return *this;
55     }
56     // used for text output
operator base_type() const57     operator base_type () const {
58         return t;
59     }
60     // used for text input
operator base_type&()61     operator base_type & (){
62         return t;
63     }
operator ==(const library_version_type & rhs) const64     bool operator==(const library_version_type & rhs) const {
65         return t == rhs.t;
66     }
operator <(const library_version_type & rhs) const67     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!!!
version_type()81     version_type(): t(0) {};
version_type(const unsigned int & t_)82     explicit version_type(const unsigned int & t_) : t(t_){
83         BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
84     }
version_type(const version_type & t_)85     version_type(const version_type & t_) :
86         t(t_.t)
87     {}
operator =(const version_type & rhs)88     version_type & operator=(const version_type & rhs){
89         t = rhs.t;
90         return *this;
91     }
92     // used for text output
operator base_type() const93     operator base_type () const {
94         return t;
95     }
96     // used for text intput
operator base_type&()97     operator base_type  & (){
98         return t;
99     }
operator ==(const version_type & rhs) const100     bool operator==(const version_type & rhs) const {
101         return t == rhs.t;
102     }
operator <(const version_type & rhs) const103     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
class_id_type()114     class_id_type() : t(0) {};
class_id_type(const int t_)115     explicit class_id_type(const int t_) : t(t_){
116         BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
117     }
class_id_type(const std::size_t t_)118     explicit class_id_type(const std::size_t t_) : t(t_){
119  //       BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
120     }
class_id_type(const class_id_type & t_)121     class_id_type(const class_id_type & t_) :
122         t(t_.t)
123     {}
operator =(const class_id_type & rhs)124     class_id_type & operator=(const class_id_type & rhs){
125         t = rhs.t;
126         return *this;
127     }
128 
129     // used for text output
operator int() const130     operator int () const {
131         return t;
132     }
133     // used for text input
operator int_least16_t&()134     operator int_least16_t &() {
135         return t;
136     }
operator ==(const class_id_type & rhs) const137     bool operator==(const class_id_type & rhs) const {
138         return t == rhs.t;
139     }
operator <(const class_id_type & rhs) const140     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:
object_id_type()152     object_id_type(): t(0) {};
object_id_type(const unsigned int & t_)153     explicit object_id_type(const unsigned int & t_) : t(t_){
154         BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
155     }
object_id_type(const object_id_type & t_)156     object_id_type(const object_id_type & t_) :
157         t(t_.t)
158     {}
operator =(const object_id_type & rhs)159     object_id_type & operator=(const object_id_type & rhs){
160         t = rhs.t;
161         return *this;
162     }
163     // used for text output
operator uint_least32_t() const164     operator uint_least32_t () const {
165         return t;
166     }
167     // used for text input
operator uint_least32_t&()168     operator uint_least32_t & () {
169         return t;
170     }
operator ==(const object_id_type & rhs) const171     bool operator==(const object_id_type & rhs) const {
172         return t == rhs.t;
173     }
operator <(const object_id_type & rhs) const174     bool operator<(const object_id_type & rhs) const {
175         return t < rhs.t;
176     }
177 };
178 
179 #if defined(_MSC_VER)
180 #pragma warning( pop )
181 #endif
182 
183 struct tracking_type {
184     bool t;
tracking_typeboost::archive::tracking_type185     explicit tracking_type(const bool t_ = false)
186         : t(t_)
187     {};
tracking_typeboost::archive::tracking_type188     tracking_type(const tracking_type & t_)
189         : t(t_.t)
190     {}
operator boolboost::archive::tracking_type191     operator bool () const {
192         return t;
193     };
operator bool&boost::archive::tracking_type194     operator bool & () {
195         return t;
196     };
operator =boost::archive::tracking_type197     tracking_type & operator=(const bool t_){
198         t = t_;
199         return *this;
200     }
operator ==boost::archive::tracking_type201     bool operator==(const tracking_type & rhs) const {
202         return t == rhs.t;
203     }
operator ==boost::archive::tracking_type204     bool operator==(const bool & rhs) const {
205         return t == rhs;
206     }
operator =boost::archive::tracking_type207     tracking_type & operator=(const tracking_type & rhs){
208         t = rhs.t;
209         return *this;
210     }
211 };
212 
213 struct class_name_type :
214     private boost::noncopyable
215 {
216     char *t;
operator const char*&boost::archive::class_name_type217     operator const char * & () const {
218         return const_cast<const char * &>(t);
219     }
operator char*boost::archive::class_name_type220     operator char * () {
221         return t;
222     }
class_name_typeboost::archive::class_name_type223     explicit class_name_type(const char *key_)
224     : t(const_cast<char *>(key_)){}
class_name_typeboost::archive::class_name_type225     explicit class_name_type(char *key_)
226     : t(key_){}
operator =boost::archive::class_name_type227     class_name_type & operator=(const class_name_type & rhs){
228         t = rhs.t;
229         return *this;
230     }
231 };
232 
233 enum archive_flags {
234     no_header = 1,  // suppress archive header info
235     no_codecvt = 2,  // suppress alteration of codecvt facet
236     no_xml_tag_checking = 4,   // suppress checking of xml tags
237     no_tracking = 8,           // suppress ALL tracking
238     flags_last = 8
239 };
240 
241 BOOST_ARCHIVE_DECL(const char *)
242 BOOST_ARCHIVE_SIGNATURE();
243 
244 /* NOTE : Warning  : Warning : Warning : Warning : Warning
245  * If any of these are changed to different sized types,
246  * binary_iarchive won't be able to read older archives
247  * unless you rev the library version and include conditional
248  * code based on the library version.  There is nothing
249  * inherently wrong in doing this - but you have to be super
250  * careful because it's easy to get wrong and start breaking
251  * old archives !!!
252  */
253 
254 #define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D)         \
255     class D : public T {                           \
256     public:                                        \
257         explicit D(const T tt) : T(tt){}           \
258     };                                             \
259 /**/
260 
261 BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_reference_type)
262 BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_optional_type)
263 BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type)
264 
265 }// namespace archive
266 }// namespace boost
267 
268 #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
269 
270 #include <boost/serialization/level.hpp>
271 
272 // set implementation level to primitive for all types
273 // used internally by the serialization library
274 
275 BOOST_CLASS_IMPLEMENTATION(boost::archive::library_version_type, primitive_type)
276 BOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type)
277 BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type)
278 BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type)
279 BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_optional_type, primitive_type)
280 BOOST_CLASS_IMPLEMENTATION(boost::archive::class_name_type, primitive_type)
281 BOOST_CLASS_IMPLEMENTATION(boost::archive::object_id_type, primitive_type)
282 BOOST_CLASS_IMPLEMENTATION(boost::archive::object_reference_type, primitive_type)
283 BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type)
284 
285 #include <boost/serialization/is_bitwise_serializable.hpp>
286 
287 // set types used internally by the serialization library
288 // to be bitwise serializable
289 
290 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::library_version_type)
291 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::version_type)
292 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type)
293 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type)
294 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_optional_type)
295 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_name_type)
296 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_id_type)
297 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_reference_type)
298 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::tracking_type)
299 
300 #endif //BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
301