1#ifndef BOOST_SERIALIZATION_SMART_CAST_HPP
2#define BOOST_SERIALIZATION_SMART_CAST_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// smart_cast.hpp:
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/libs/serialization for updates, documentation, and revision history.
18
19// casting of pointers and references.
20
21// In casting between different C++ classes, there are a number of
22// rules that have to be kept in mind in deciding whether to use
23// static_cast or dynamic_cast.
24
25// a) dynamic casting can only be applied when one of the types is polymorphic
26// Otherwise static_cast must be used.
27// b) only dynamic casting can do runtime error checking
28// use of static_cast is generally un checked even when compiled for debug
29// c) static_cast would be considered faster than dynamic_cast.
30
31// If casting is applied to a template parameter, there is no apriori way
32// to know which of the two casting methods will be permitted or convenient.
33
34// smart_cast uses C++ type_traits, and program debug mode to select the
35// most convenient cast to use.
36
37#include <exception>
38#include <typeinfo>
39#include <cstddef> // NULL
40
41#include <boost/config.hpp>
42#include <boost/static_assert.hpp>
43
44#include <boost/type_traits/is_base_and_derived.hpp>
45#include <boost/type_traits/is_polymorphic.hpp>
46#include <boost/type_traits/is_pointer.hpp>
47#include <boost/type_traits/is_reference.hpp>
48#include <boost/type_traits/is_same.hpp>
49#include <boost/type_traits/remove_pointer.hpp>
50#include <boost/type_traits/remove_reference.hpp>
51
52#include <boost/mpl/eval_if.hpp>
53#include <boost/mpl/if.hpp>
54#include <boost/mpl/or.hpp>
55#include <boost/mpl/and.hpp>
56#include <boost/mpl/not.hpp>
57#include <boost/mpl/identity.hpp>
58
59#include <boost/serialization/throw_exception.hpp>
60
61namespace boost {
62namespace serialization {
63namespace smart_cast_impl {
64
65 template<class T>
66 struct reference {
67
68 struct polymorphic {
69
70 struct linear {
71 template<class U>
72 static T cast(U & u){
73 return static_cast< T >(u);
74 }
75 };
76
77 struct cross {
78 template<class U>
79 static T cast(U & u){
80 return dynamic_cast< T >(u);
81 }
82 };
83
84 template<class U>
85 static T cast(U & u){
86 // if we're in debug mode
87 #if ! defined(NDEBUG) \
88 || defined(__MWERKS__)
89 // do a checked dynamic cast
90 return cross::cast(u);
91 #else
92 // borland 5.51 chokes here so we can't use it
93 // note: if remove_reference isn't function for these types
94 // cross casting will be selected this will work but will
95 // not be the most efficient method. This will conflict with
96 // the original smart_cast motivation.
97 typedef typename mpl::eval_if<
98 typename mpl::and_<
99 mpl::not_<is_base_and_derived<
100 typename remove_reference< T >::type,
101 U
102 > >,
103 mpl::not_<is_base_and_derived<
104 U,
105 typename remove_reference< T >::type
106 > >
107 >,
108 // borland chokes w/o full qualification here
109 mpl::identity<cross>,
110 mpl::identity<linear>
111 >::type typex;
112 // typex works around gcc 2.95 issue
113 return typex::cast(u);
114 #endif
115 }
116 };
117
118 struct non_polymorphic {
119 template<class U>
120 static T cast(U & u){
121 return static_cast< T >(u);
122 }
123 };
124 template<class U>
125 static T cast(U & u){
126 typedef typename mpl::eval_if<
127 boost::is_polymorphic<U>,
128 mpl::identity<polymorphic>,
129 mpl::identity<non_polymorphic>
130 >::type typex;
131 return typex::cast(u);
132 }
133 };
134
135 template<class T>
136 struct pointer {
137
138 struct polymorphic {
139 // unfortunately, this below fails to work for virtual base
140 // classes. need has_virtual_base to do this.
141 // Subject for further study
142 #if 0
143 struct linear {
144 template<class U>
145 static T cast(U * u){
146 return static_cast< T >(u);
147 }
148 };
149
150 struct cross {
151 template<class U>
152 static T cast(U * u){
153 T tmp = dynamic_cast< T >(u);
154 #ifndef NDEBUG
155 if ( tmp == 0 ) throw_exception(std::bad_cast());
156 #endif
157 return tmp;
158 }
159 };
160
161 template<class U>
162 static T cast(U * u){
163 typedef
164 typename mpl::eval_if<
165 typename mpl::and_<
166 mpl::not_<is_base_and_derived<
167 typename remove_pointer< T >::type,
168 U
169 > >,
170 mpl::not_<is_base_and_derived<
171 U,
172 typename remove_pointer< T >::type
173 > >
174 >,
175 // borland chokes w/o full qualification here
176 mpl::identity<cross>,
177 mpl::identity<linear>
178 >::type typex;
179 return typex::cast(u);
180 }
181 #else
182 template<class U>
183 static T cast(U * u){
184 T tmp = dynamic_cast< T >(u);
185 #ifndef NDEBUG
186 if ( tmp == 0 ) throw_exception(std::bad_cast());
187 #endif
188 return tmp;
189 }
190 #endif
191 };
192
193 struct non_polymorphic {
194 template<class U>
195 static T cast(U * u){
196 return static_cast< T >(u);
197 }
198 };
199
200 template<class U>
201 static T cast(U * u){
202 typedef typename mpl::eval_if<
203 boost::is_polymorphic<U>,
204 mpl::identity<polymorphic>,
205 mpl::identity<non_polymorphic>
206 >::type typex;
207 return typex::cast(u);
208 }
209
210 };
211
212 template<class TPtr>
213 struct void_pointer {
214 template<class UPtr>
215 static TPtr cast(UPtr uptr){
216 return static_cast<TPtr>(uptr);
217 }
218 };
219
220 template<class T>
221 struct error {
222 // if we get here, its because we are using one argument in the
223 // cast on a system which doesn't support partial template
224 // specialization
225 template<class U>
226 static T cast(U){
227 BOOST_STATIC_ASSERT(sizeof(T)==0);
228 return * static_cast<T *>(NULL);
229 }
230 };
231
232} // smart_cast_impl
233
234// this implements:
235// smart_cast<Target *, Source *>(Source * s)
236// smart_cast<Target &, Source &>(s)
237// note that it will fail with
238// smart_cast<Target &>(s)
239template<class T, class U>
240T smart_cast(U u) {
241 typedef
242 typename mpl::eval_if<
243 typename mpl::or_<
244 boost::is_same<void *, U>,
245 boost::is_same<void *, T>,
246 boost::is_same<const void *, U>,
247 boost::is_same<const void *, T>
248 >,
249 mpl::identity<smart_cast_impl::void_pointer< T > >,
250 // else
251 typename mpl::eval_if<boost::is_pointer<U>,
252 mpl::identity<smart_cast_impl::pointer< T > >,
253 // else
254 typename mpl::eval_if<boost::is_reference<U>,
255 mpl::identity<smart_cast_impl::reference< T > >,
256 // else
257 mpl::identity<smart_cast_impl::error< T >
258 >
259 >
260 >
261 >::type typex;
262 return typex::cast(u);
263}
264
265// this implements:
266// smart_cast_reference<Target &>(Source & s)
267template<class T, class U>
268T smart_cast_reference(U & u) {
269 return smart_cast_impl::reference< T >::cast(u);
270}
271
272} // namespace serialization
273} // namespace boost
274
275#endif // BOOST_SERIALIZATION_SMART_CAST_HPP
276