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// note the usage of function overloading to compensate that C++ does not
49// currently support Partial Template Specialization for function templates
50// We have declared the version number as "const unsigned long".
51// Overriding templates for specific data types should declare the version
52// number as "const unsigned int". Template matching will first be applied
53// to functions with the same version types - that is the overloads.
54// If there is no declared function prototype that matches, the second argument
55// will be converted to "const unsigned long" and a match will be made with
56// one of the default template functions below.
57
58namespace boost {
59namespace serialization {
60
61BOOST_STRONG_TYPEDEF(unsigned int, version_type)
62
63// default implementation - call the member function "serialize"
64template<class Archive, class T>
65inline void serialize(
66 Archive & ar, T & t, const unsigned int file_version
67){
68 access::serialize(ar, t, static_cast<unsigned int>(file_version));
69}
70
71// save data required for construction
72template<class Archive, class T>
73inline void save_construct_data(
74 Archive & /*ar*/,
75 const T * /*t*/,
76 const unsigned int /*file_version */
77){
78 // default is to save no data because default constructor
79 // requires no arguments.
80}
81
82// load data required for construction and invoke constructor in place
83template<class Archive, class T>
84inline void load_construct_data(
85 Archive & /*ar*/,
86 T * t,
87 const unsigned int /*file_version*/
88){
89 // default just uses the default constructor. going
90 // through access permits usage of otherwise private default
91 // constructor
92 access::construct(t);
93}
94
95/////////////////////////////////////////////////////////////////////////////
96// layer 3 - move call into serialization namespace so that ADL will function
97// in the manner we desire.
98//
99// on compilers which don't implement ADL. only the current namespace
100// i.e. boost::serialization will be searched.
101//
102// on compilers which DO implement ADL
103// serialize overrides can be in any of the following
104//
105// 1) same namepace as Archive
106// 2) same namespace as T
107// 3) boost::serialization
108//
109// Due to Martin Ecker
110
111template<class Archive, class T>
112inline void serialize_adl(
113 Archive & ar,
114 T & t,
115 const unsigned int file_version
116){
117 const version_type v(file_version);
118 serialize(ar, t, v);
119}
120
121template<class Archive, class T>
122inline void save_construct_data_adl(
123 Archive & ar,
124 const T * t,
125 const unsigned int file_version
126){
127
128 const version_type v(file_version);
129 save_construct_data(ar, t, v);
130}
131
132template<class Archive, class T>
133inline void load_construct_data_adl(
134 Archive & ar,
135 T * t,
136 const unsigned int file_version
137){
138 // see above comment
139 const version_type v(file_version);
140 load_construct_data(ar, t, v);
141}
142
143} // namespace serialization
144} // namespace boost
145
146#endif //BOOST_SERIALIZATION_SERIALIZATION_HPP
147

source code of include/boost/serialization/serialization.hpp