boost/serialization/serialization.hpp

   1 #ifndef BOOST_SERIALIZATION_SERIALIZATION_HPP
   2 #define BOOST_SERIALIZATION_SERIALIZATION_HPP
   3
   4 // MS compatible compilers support #pragma once
   5 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
   6 # pragma once
   7 #endif
   8
   9 #if defined(_MSC_VER) && (_MSC_VER >= 1310)
  10 #  pragma warning (disable : 4675) // suppress ADL warning
  11 #endif
  12
  13 #include <boost/config.hpp>
  14 #include <boost/serialization/strong_typedef.hpp>
  15 #include <boost/serialization/pfto.hpp>
  16 #include <boost/serialization/throw_exception.hpp>
  17 #include <boost/serialization/nvp.hpp>
  18
  19 // incremented for each "release"
  20 #define BOOST_SERIALIZATION_LIBRARY_VERSION 19
  21
  22 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
  23 // serialization.hpp: interface for serialization system.
  24
  25 // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
  26 // Use, modification and distribution is subject to the Boost Software
  27 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
  28 // http://www.boost.org/LICENSE_1_0.txt)
  29
  30 //  See http://www.boost.org for updates, documentation, and revision history.
  31
  32 //////////////////////////////////////////////////////////////////////
  33 // public interface to serialization.
  34
  35 /////////////////////////////////////////////////////////////////////////////
  36 // layer 0 - intrusive verison
  37 // declared and implemented for each user defined class to be serialized
  38 //
  39 //  template<Archive>
  40 //  serialize(Archive &ar, const unsigned int file_version){
  41 //      ar & base_object<base>(*this) & member1 & member2 ... ;
  42 //  }
  43
  44 /////////////////////////////////////////////////////////////////////////////
  45 // layer 1 - layer that routes member access through the access class.
  46 // this is what permits us to grant access to private class member functions
  47 // by specifying friend class boost::serialization::access
  48
  49 #include <boost/serialization/access.hpp>
  50
  51 /////////////////////////////////////////////////////////////////////////////
  52 // layer 2 - default implementation of non-intrusive serialization.
  53 //
  54 // note the usage of function overloading to compensate that C++ does not
  55 // currently support Partial Template Specialization for function templates
  56 // We have declared the version number as "const unsigned long".
  57 // Overriding templates for specific data types should declare the version
  58 // number as "const unsigned int". Template matching will first be applied
  59 // to functions with the same version types - that is the overloads.
  60 // If there is no declared function prototype that matches, the second argument
  61 // will be converted to "const unsigned long" and a match will be made with
  62 // one of the default template functions below.
  63
  64 namespace boost {
  65 namespace serialization {
  66
  67 BOOST_STRONG_TYPEDEF(unsigned int, version_type)
  68
  69 // default implemenation - call the member function "serialize"
  70 template<class Archive, class T>
  71 inline void serialize(
  72     Archive & ar, T & t, const BOOST_PFTO unsigned int file_version
  73 ){
  74     access::serialize(ar, t, static_cast<unsigned int>(file_version));
  75 }
  76
  77 // save data required for construction
  78 template<class Archive, class T>
  79 inline void save_construct_data(
  80     Archive & /*ar*/,
  81     const T * /*t*/,
  82     const BOOST_PFTO unsigned int /*file_version */
  83 ){
  84     // default is to save no data because default constructor
  85     // requires no arguments.
  86 }
  87
  88 // load data required for construction and invoke constructor in place
  89 template<class Archive, class T>
  90 inline void load_construct_data(
  91     Archive & ar,
  92     T * t,
  93     const BOOST_PFTO unsigned int /*file_version*/
  94 ){
  95     // default just uses the default constructor.  going
  96     // through access permits usage of otherwise private default
  97     // constructor
  98     access::construct(ar, t);
  99 }
 100
 101 /////////////////////////////////////////////////////////////////////////////
 102 // layer 3 - move call into serialization namespace so that ADL will function
 103 // in the manner we desire.
 104 //
 105 // on compilers which don't implement ADL. only the current namespace
 106 // i.e. boost::serialization will be searched.
 107 //
 108 // on compilers which DO implement ADL
 109 // serialize overrides can be in any of the following
 110 //
 111 // 1) same namepace as Archive
 112 // 2) same namespace as T
 113 // 3) boost::serialization
 114 //
 115 // Due to Martin Ecker
 116
 117 template<class Archive, class T>
 118 inline void serialize_adl(
 119     Archive & ar,
 120     T & t,
 121     const unsigned int file_version
 122 ){
 123     // note usage of function overloading to delay final resolution
 124     // until the point of instantiation.  This works around the two-phase
 125     // lookup "feature" which inhibits redefintion of a default function
 126     // template implementation. Due to Robert Ramey
 127     //
 128     // Note that this trick generates problems for compiles which don't support
 129     // PFTO, suppress it here.  As far as we know, there are no compilers
 130     // which fail to support PFTO while supporting two-phase lookup.
 131     #if ! defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
 132         const version_type v(file_version);
 133         serialize(ar, t, v);
 134     #else
 135         serialize(ar, t, file_version);
 136     #endif
 137 }
 138
 139 template<class Archive, class T>
 140 inline void save_construct_data_adl(
 141     Archive & ar,
 142     const T * t,
 143     const unsigned int file_version
 144 ){
 145     // see above
 146     #if ! defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
 147         const version_type v(file_version);
 148         save_construct_data(ar, t, v);
 149     #else
 150         save_construct_data(ar, t, file_version);
 151     #endif
 152 }
 153
 154 template<class Archive, class T>
 155 inline void load_construct_data_adl(
 156     Archive & ar,
 157     T * t,
 158     const unsigned int file_version
 159 ){
 160     // see above comment
 161     #if ! defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
 162         const version_type v(file_version);
 163         load_construct_data(ar, t, v);
 164     #else
 165         load_construct_data(ar, t, file_version);
 166     #endif
 167 }
 168
 169 } // namespace serialization
 170 } // namespace boost
 171
 172 #endif //BOOST_SERIALIZATION_SERIALIZATION_HPP