1 #ifndef BOOST_SERIALIZATION_ACCESS_HPP
2 #define BOOST_SERIALIZATION_ACCESS_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 // access.hpp: interface for serialization system.
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 
19 #include <boost/config.hpp>
20 
21 namespace boost {
22 
23 namespace archive {
24 namespace detail {
25     template<class Archive, class T>
26     class iserializer;
27     template<class Archive, class T>
28     class oserializer;
29 } // namespace detail
30 } // namespace archive
31 
32 namespace serialization {
33 
34 // forward declarations
35 template<class Archive, class T>
36 inline void serialize_adl(Archive &, T &, const unsigned int);
37 namespace detail {
38     template<class Archive, class T>
39     struct member_saver;
40     template<class Archive, class T>
41     struct member_loader;
42 } // namespace detail
43 
44 // use an "accessor class so that we can use:
45 // "friend class boost::serialization::access;"
46 // in any serialized class to permit clean, safe access to private class members
47 // by the serialization system
48 
49 class access {
50 public:
51     // grant access to "real" serialization defaults
52 #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
53 public:
54 #else
55     template<class Archive, class T>
56     friend struct detail::member_saver;
57     template<class Archive, class T>
58     friend struct detail::member_loader;
59     template<class Archive, class T>
60     friend class archive::detail::iserializer;
61     template<class Archive, class T>
62     friend class archive::detail::oserializer;
63     template<class Archive, class T>
64     friend inline void serialize(
65         Archive & ar,
66         T & t,
67         const unsigned int file_version
68     );
69     template<class Archive, class T>
70     friend inline void save_construct_data(
71         Archive & ar,
72         const T * t,
73         const unsigned int file_version
74     );
75     template<class Archive, class T>
76     friend inline void load_construct_data(
77         Archive & ar,
78         T * t,
79         const unsigned int file_version
80     );
81 #endif
82 
83     // pass calls to users's class implementation
84     template<class Archive, class T>
member_save(Archive & ar,T & t,const unsigned int file_version)85     static void member_save(
86         Archive & ar,
87         //const T & t,
88         T & t,
89         const unsigned int file_version
90     ){
91         t.save(ar, file_version);
92     }
93     template<class Archive, class T>
member_load(Archive & ar,T & t,const unsigned int file_version)94     static void member_load(
95         Archive & ar,
96         T & t,
97         const unsigned int file_version
98     ){
99         t.load(ar, file_version);
100     }
101     template<class Archive, class T>
serialize(Archive & ar,T & t,const unsigned int file_version)102     static void serialize(
103         Archive & ar,
104         T & t,
105         const unsigned int file_version
106     ){
107         // note: if you get a compile time error here with a
108         // message something like:
109         // cannot convert parameter 1 from <file type 1> to <file type 2 &>
110         // a likely possible cause is that the class T contains a
111         // serialize function - but that serialize function isn't
112         // a template and corresponds to a file type different than
113         // the class Archive.  To resolve this, don't include an
114         // archive type other than that for which the serialization
115         // function is defined!!!
116         t.serialize(ar, file_version);
117     }
118     template<class T>
destroy(const T * t)119     static void destroy( const T * t) // const appropriate here?
120     {
121         // the const business is an MSVC 6.0 hack that should be
122         // benign on everything else
123         delete const_cast<T *>(t);
124     }
125     template<class T>
construct(T * t)126     static void construct(T * t){
127         // default is inplace invocation of default constructor
128         // Note the :: before the placement new. Required if the
129         // class doesn't have a class-specific placement new defined.
130         ::new(t)T;
131     }
132     template<class T, class U>
cast_reference(U & u)133     static T & cast_reference(U & u){
134         return static_cast<T &>(u);
135     }
136     template<class T, class U>
cast_pointer(U * u)137     static T * cast_pointer(U * u){
138         return static_cast<T *>(u);
139     }
140 };
141 
142 } // namespace serialization
143 } // namespace boost
144 
145 #endif // BOOST_SERIALIZATION_ACCESS_HPP
146