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/integer_traits.hpp> 22 #include <boost/noncopyable.hpp> 23 #include <boost/serialization/library_version_type.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 BOOST_ARCHIVE_DECL boost::serialization::library_version_type 37 BOOST_ARCHIVE_VERSION(); 38 39 // create alias in boost::archive for older user code. 40 typedef boost::serialization::library_version_type library_version_type; 41 42 class version_type { 43 private: 44 typedef uint_least32_t base_type; 45 base_type t; 46 public: 47 // should be private - but MPI fails if it's not!!! version_type()48 version_type(): t(0) {} version_type(const unsigned int & t_)49 explicit version_type(const unsigned int & t_) : t(t_){ 50 BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max); 51 } version_type(const version_type & t_)52 version_type(const version_type & t_) : 53 t(t_.t) 54 {} operator =(const version_type & rhs)55 version_type & operator=(const version_type & rhs){ 56 t = rhs.t; 57 return *this; 58 } 59 // used for text output operator base_type() const60 operator base_type () const { 61 return t; 62 } 63 // used for text intput operator base_type&()64 operator base_type & (){ 65 return t; 66 } operator ==(const version_type & rhs) const67 bool operator==(const version_type & rhs) const { 68 return t == rhs.t; 69 } operator <(const version_type & rhs) const70 bool operator<(const version_type & rhs) const { 71 return t < rhs.t; 72 } 73 }; 74 75 class class_id_type { 76 private: 77 typedef int_least16_t base_type; 78 base_type t; 79 public: 80 // should be private - but then can't use BOOST_STRONG_TYPE below class_id_type()81 class_id_type() : t(0) {} class_id_type(const int t_)82 explicit class_id_type(const int t_) : t(t_){ 83 BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max); 84 } class_id_type(const std::size_t t_)85 explicit class_id_type(const std::size_t t_) : t(t_){ 86 // BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max); 87 } class_id_type(const class_id_type & t_)88 class_id_type(const class_id_type & t_) : 89 t(t_.t) 90 {} operator =(const class_id_type & rhs)91 class_id_type & operator=(const class_id_type & rhs){ 92 t = rhs.t; 93 return *this; 94 } 95 96 // used for text output operator base_type() const97 operator base_type () const { 98 return t; 99 } 100 // used for text input operator base_type&()101 operator base_type &() { 102 return t; 103 } operator ==(const class_id_type & rhs) const104 bool operator==(const class_id_type & rhs) const { 105 return t == rhs.t; 106 } operator <(const class_id_type & rhs) const107 bool operator<(const class_id_type & rhs) const { 108 return t < rhs.t; 109 } 110 }; 111 112 #define BOOST_SERIALIZATION_NULL_POINTER_TAG boost::archive::class_id_type(-1) 113 114 class object_id_type { 115 private: 116 typedef uint_least32_t base_type; 117 base_type t; 118 public: object_id_type()119 object_id_type(): t(0) {} 120 // note: presumes that size_t >= unsigned int. 121 // use explicit cast to silence useless warning object_id_type(const std::size_t & t_)122 explicit object_id_type(const std::size_t & t_) : t(static_cast<base_type>(t_)){ 123 // make quadruple sure that we haven't lost any real integer 124 // precision 125 BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max); 126 } object_id_type(const object_id_type & t_)127 object_id_type(const object_id_type & t_) : 128 t(t_.t) 129 {} operator =(const object_id_type & rhs)130 object_id_type & operator=(const object_id_type & rhs){ 131 t = rhs.t; 132 return *this; 133 } 134 // used for text output operator base_type() const135 operator base_type () const { 136 return t; 137 } 138 // used for text input operator base_type&()139 operator base_type & () { 140 return t; 141 } operator ==(const object_id_type & rhs) const142 bool operator==(const object_id_type & rhs) const { 143 return t == rhs.t; 144 } operator <(const object_id_type & rhs) const145 bool operator<(const object_id_type & rhs) const { 146 return t < rhs.t; 147 } 148 }; 149 150 #if defined(_MSC_VER) 151 #pragma warning( pop ) 152 #endif 153 154 struct tracking_type { 155 bool t; tracking_typeboost::archive::tracking_type156 explicit tracking_type(const bool t_ = false) 157 : t(t_) 158 {} tracking_typeboost::archive::tracking_type159 tracking_type(const tracking_type & t_) 160 : t(t_.t) 161 {} operator boolboost::archive::tracking_type162 operator bool () const { 163 return t; 164 } operator bool&boost::archive::tracking_type165 operator bool & () { 166 return t; 167 } operator =boost::archive::tracking_type168 tracking_type & operator=(const bool t_){ 169 t = t_; 170 return *this; 171 } operator ==boost::archive::tracking_type172 bool operator==(const tracking_type & rhs) const { 173 return t == rhs.t; 174 } operator ==boost::archive::tracking_type175 bool operator==(const bool & rhs) const { 176 return t == rhs; 177 } operator =boost::archive::tracking_type178 tracking_type & operator=(const tracking_type & rhs){ 179 t = rhs.t; 180 return *this; 181 } 182 }; 183 184 struct class_name_type : 185 private boost::noncopyable 186 { 187 char *t; operator const char*&boost::archive::class_name_type188 operator const char * & () const { 189 return const_cast<const char * &>(t); 190 } operator char*boost::archive::class_name_type191 operator char * () { 192 return t; 193 } sizeboost::archive::class_name_type194 std::size_t size() const { 195 return std::strlen(t); 196 } class_name_typeboost::archive::class_name_type197 explicit class_name_type(const char *key_) 198 : t(const_cast<char *>(key_)){} class_name_typeboost::archive::class_name_type199 explicit class_name_type(char *key_) 200 : t(key_){} operator =boost::archive::class_name_type201 class_name_type & operator=(const class_name_type & rhs){ 202 t = rhs.t; 203 return *this; 204 } 205 }; 206 207 enum archive_flags { 208 no_header = 1, // suppress archive header info 209 no_codecvt = 2, // suppress alteration of codecvt facet 210 no_xml_tag_checking = 4, // suppress checking of xml tags 211 no_tracking = 8, // suppress ALL tracking 212 flags_last = 8 213 }; 214 215 BOOST_ARCHIVE_DECL const char * 216 BOOST_ARCHIVE_SIGNATURE(); 217 218 /* NOTE : Warning : Warning : Warning : Warning : Warning 219 * If any of these are changed to different sized types, 220 * binary_iarchive won't be able to read older archives 221 * unless you rev the library version and include conditional 222 * code based on the library version. There is nothing 223 * inherently wrong in doing this - but you have to be super 224 * careful because it's easy to get wrong and start breaking 225 * old archives !!! 226 */ 227 228 #define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D) \ 229 class D : public T { \ 230 public: \ 231 explicit D(const T tt) : T(tt){} \ 232 }; \ 233 /**/ 234 235 BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_reference_type) 236 BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_optional_type) 237 BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type) 238 239 }// namespace archive 240 }// namespace boost 241 242 #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas 243 244 #include <boost/serialization/level.hpp> 245 246 // set implementation level to primitive for all types 247 // used internally by the serialization library 248 249 BOOST_CLASS_IMPLEMENTATION(boost::serialization::library_version_type, primitive_type) 250 BOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type) 251 BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type) 252 BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type) 253 BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_optional_type, primitive_type) 254 BOOST_CLASS_IMPLEMENTATION(boost::archive::class_name_type, primitive_type) 255 BOOST_CLASS_IMPLEMENTATION(boost::archive::object_id_type, primitive_type) 256 BOOST_CLASS_IMPLEMENTATION(boost::archive::object_reference_type, primitive_type) 257 BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type) 258 259 #include <boost/serialization/is_bitwise_serializable.hpp> 260 261 // set types used internally by the serialization library 262 // to be bitwise serializable 263 264 BOOST_IS_BITWISE_SERIALIZABLE(boost::serialization::library_version_type) 265 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::version_type) 266 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type) 267 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type) 268 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_optional_type) 269 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_name_type) 270 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_id_type) 271 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_reference_type) 272 BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::tracking_type) 273 274 #endif //BOOST_ARCHIVE_BASIC_ARCHIVE_HPP 275