ceph/src/boost/libs/serialization/include/boost/archive/basic_archive.hpp

   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