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)
6 # pragma once
7 #endif
8
9 #if defined(_MSC_VER)
10 # pragma warning (disable : 4675) // suppress ADL warning
11 #endif
12
13 #include <boost/config.hpp>
14 #include <boost/serialization/strong_typedef.hpp>
15
16 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
17 // serialization.hpp: interface for serialization system.
18
19 // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
20 // Use, modification and distribution is subject to the Boost Software
21 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
22 // http://www.boost.org/LICENSE_1_0.txt)
23
24 // See http://www.boost.org for updates, documentation, and revision history.
25
26 //////////////////////////////////////////////////////////////////////
27 // public interface to serialization.
28
29 /////////////////////////////////////////////////////////////////////////////
30 // layer 0 - intrusive verison
31 // declared and implemented for each user defined class to be serialized
32 //
33 // template<Archive>
34 // serialize(Archive &ar, const unsigned int file_version){
35 // ar & base_object<base>(*this) & member1 & member2 ... ;
36 // }
37
38 /////////////////////////////////////////////////////////////////////////////
39 // layer 1 - layer that routes member access through the access class.
40 // this is what permits us to grant access to private class member functions
41 // by specifying friend class boost::serialization::access
42
43 #include <boost/serialization/access.hpp>
44
45 /////////////////////////////////////////////////////////////////////////////
46 // layer 2 - default implementation of non-intrusive serialization.
47 //
48
49 namespace boost {
50 namespace serialization {
51
BOOST_STRONG_TYPEDEF(unsigned int,version_type)52 BOOST_STRONG_TYPEDEF(unsigned int, version_type)
53
54 // default implementation - call the member function "serialize"
55 template<class Archive, class T>
56 inline void serialize(
57 Archive & ar, T & t, const unsigned int file_version
58 ){
59 access::serialize(ar, t, static_cast<unsigned int>(file_version));
60 }
61
62 // save data required for construction
63 template<class Archive, class T>
save_construct_data(Archive &,const T *,const unsigned int)64 inline void save_construct_data(
65 Archive & /*ar*/,
66 const T * /*t*/,
67 const unsigned int /*file_version */
68 ){
69 // default is to save no data because default constructor
70 // requires no arguments.
71 }
72
73 // load data required for construction and invoke constructor in place
74 template<class Archive, class T>
load_construct_data(Archive &,T * t,const unsigned int)75 inline void load_construct_data(
76 Archive & /*ar*/,
77 T * t,
78 const unsigned int /*file_version*/
79 ){
80 // default just uses the default constructor. going
81 // through access permits usage of otherwise private default
82 // constructor
83 access::construct(t);
84 }
85
86 /////////////////////////////////////////////////////////////////////////////
87 // layer 3 - move call into serialization namespace so that ADL will function
88 // in the manner we desire.
89 //
90 // on compilers which don't implement ADL. only the current namespace
91 // i.e. boost::serialization will be searched.
92 //
93 // on compilers which DO implement ADL
94 // serialize overrides can be in any of the following
95 //
96 // 1) same namepace as Archive
97 // 2) same namespace as T
98 // 3) boost::serialization
99 //
100 // Due to Martin Ecker
101
102 template<class Archive, class T>
serialize_adl(Archive & ar,T & t,const unsigned int file_version)103 inline void serialize_adl(
104 Archive & ar,
105 T & t,
106 const unsigned int file_version
107 ){
108 const version_type v(file_version);
109 serialize(ar, t, v);
110 }
111
112 template<class Archive, class T>
save_construct_data_adl(Archive & ar,const T * t,const unsigned int file_version)113 inline void save_construct_data_adl(
114 Archive & ar,
115 const T * t,
116 const unsigned int file_version
117 ){
118
119 const version_type v(file_version);
120 save_construct_data(ar, t, v);
121 }
122
123 template<class Archive, class T>
load_construct_data_adl(Archive & ar,T * t,const unsigned int file_version)124 inline void load_construct_data_adl(
125 Archive & ar,
126 T * t,
127 const unsigned int file_version
128 ){
129 // see above comment
130 const version_type v(file_version);
131 load_construct_data(ar, t, v);
132 }
133
134 } // namespace serialization
135 } // namespace boost
136
137 #endif //BOOST_SERIALIZATION_SERIALIZATION_HPP
138