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