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