1 // Copyright David Abrahams 2002.
2 // Distributed under the Boost Software License, Version 1.0. (See
3 // accompanying file LICENSE_1_0.txt or copy at
4 // http://www.boost.org/LICENSE_1_0.txt)
5 #ifndef INDIRECT_TRAITS_DWA2002131_HPP
6 # define INDIRECT_TRAITS_DWA2002131_HPP
7 # include <boost/type_traits/is_function.hpp>
8 # include <boost/type_traits/is_reference.hpp>
9 # include <boost/type_traits/is_pointer.hpp>
10 # include <boost/type_traits/is_class.hpp>
11 # include <boost/type_traits/is_const.hpp>
12 # include <boost/type_traits/is_volatile.hpp>
13 # include <boost/type_traits/is_member_function_pointer.hpp>
14 # include <boost/type_traits/is_member_pointer.hpp>
15 # include <boost/type_traits/remove_cv.hpp>
16 # include <boost/type_traits/remove_reference.hpp>
17 # include <boost/type_traits/remove_pointer.hpp>
18 
19 # include <boost/type_traits/detail/ice_and.hpp>
20 # include <boost/detail/workaround.hpp>
21 
22 # include <boost/mpl/eval_if.hpp>
23 # include <boost/mpl/if.hpp>
24 # include <boost/mpl/bool.hpp>
25 # include <boost/mpl/and.hpp>
26 # include <boost/mpl/not.hpp>
27 # include <boost/mpl/aux_/lambda_support.hpp>
28 
29 #  ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
30 #   include <boost/detail/is_function_ref_tester.hpp>
31 #  endif
32 
33 namespace boost { namespace detail {
34 
35 namespace indirect_traits {
36 
37 #  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
38 template <class T>
39 struct is_reference_to_const : mpl::false_
40 {
41 };
42 
43 template <class T>
44 struct is_reference_to_const<T const&> : mpl::true_
45 {
46 };
47 
48 #   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
49 template<class T>
50 struct is_reference_to_const<T const volatile&> : mpl::true_
51 {
52 };
53 #   endif
54 
55 template <class T>
56 struct is_reference_to_function : mpl::false_
57 {
58 };
59 
60 template <class T>
61 struct is_reference_to_function<T&> : is_function<T>
62 {
63 };
64 
65 template <class T>
66 struct is_pointer_to_function : mpl::false_
67 {
68 };
69 
70 // There's no such thing as a pointer-to-cv-function, so we don't need
71 // specializations for those
72 template <class T>
73 struct is_pointer_to_function<T*> : is_function<T>
74 {
75 };
76 
77 template <class T>
78 struct is_reference_to_member_function_pointer_impl : mpl::false_
79 {
80 };
81 
82 template <class T>
83 struct is_reference_to_member_function_pointer_impl<T&>
84     : is_member_function_pointer<typename remove_cv<T>::type>
85 {
86 };
87 
88 
89 template <class T>
90 struct is_reference_to_member_function_pointer
91     : is_reference_to_member_function_pointer_impl<T>
92 {
93     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
94 };
95 
96 template <class T>
97 struct is_reference_to_function_pointer_aux
98     : mpl::and_<
99           is_reference<T>
100         , is_pointer_to_function<
101               typename remove_cv<
102                   typename remove_reference<T>::type
103               >::type
104           >
105       >
106 {
107     // There's no such thing as a pointer-to-cv-function, so we don't need specializations for those
108 };
109 
110 template <class T>
111 struct is_reference_to_function_pointer
112     : mpl::if_<
113           is_reference_to_function<T>
114         , mpl::false_
115         , is_reference_to_function_pointer_aux<T>
116      >::type
117 {
118 };
119 
120 template <class T>
121 struct is_reference_to_non_const
122     : mpl::and_<
123           is_reference<T>
124         , mpl::not_<
125              is_reference_to_const<T>
126           >
127       >
128 {
129 };
130 
131 template <class T>
132 struct is_reference_to_volatile : mpl::false_
133 {
134 };
135 
136 template <class T>
137 struct is_reference_to_volatile<T volatile&> : mpl::true_
138 {
139 };
140 
141 #   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
142 template <class T>
143 struct is_reference_to_volatile<T const volatile&> : mpl::true_
144 {
145 };
146 #   endif
147 
148 
149 template <class T>
150 struct is_reference_to_pointer : mpl::false_
151 {
152 };
153 
154 template <class T>
155 struct is_reference_to_pointer<T*&> : mpl::true_
156 {
157 };
158 
159 template <class T>
160 struct is_reference_to_pointer<T* const&> : mpl::true_
161 {
162 };
163 
164 template <class T>
165 struct is_reference_to_pointer<T* volatile&> : mpl::true_
166 {
167 };
168 
169 template <class T>
170 struct is_reference_to_pointer<T* const volatile&> : mpl::true_
171 {
172 };
173 
174 template <class T>
175 struct is_reference_to_class
176     : mpl::and_<
177           is_reference<T>
178         , is_class<
179               typename remove_cv<
180                   typename remove_reference<T>::type
181               >::type
182           >
183       >
184 {
185     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
186 };
187 
188 template <class T>
189 struct is_pointer_to_class
190     : mpl::and_<
191           is_pointer<T>
192         , is_class<
193               typename remove_cv<
194                   typename remove_pointer<T>::type
195               >::type
196           >
197       >
198 {
199     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T))
200 };
201 
202 #  else
203 
204 using namespace boost::detail::is_function_ref_tester_;
205 
206 typedef char (&inner_yes_type)[3];
207 typedef char (&inner_no_type)[2];
208 typedef char (&outer_no_type)[1];
209 
210 template <typename V>
211 struct is_const_help
212 {
213     typedef typename mpl::if_<
214           is_const<V>
215         , inner_yes_type
216         , inner_no_type
217         >::type type;
218 };
219 
220 template <typename V>
221 struct is_volatile_help
222 {
223     typedef typename mpl::if_<
224           is_volatile<V>
225         , inner_yes_type
226         , inner_no_type
227         >::type type;
228 };
229 
230 template <typename V>
231 struct is_pointer_help
232 {
233     typedef typename mpl::if_<
234           is_pointer<V>
235         , inner_yes_type
236         , inner_no_type
237         >::type type;
238 };
239 
240 template <typename V>
241 struct is_class_help
242 {
243     typedef typename mpl::if_<
244           is_class<V>
245         , inner_yes_type
246         , inner_no_type
247         >::type type;
248 };
249 
250 template <class T>
251 struct is_reference_to_function_aux
252 {
253     static T t;
254     BOOST_STATIC_CONSTANT(
255         bool, value = sizeof(detail::is_function_ref_tester(t,0)) == sizeof(::boost::type_traits::yes_type));
256     typedef mpl::bool_<value> type;
257  };
258 
259 template <class T>
260 struct is_reference_to_function
261     : mpl::if_<is_reference<T>, is_reference_to_function_aux<T>, mpl::bool_<false> >::type
262 {
263 };
264 
265 template <class T>
266 struct is_pointer_to_function_aux
267 {
268     static T t;
269     BOOST_STATIC_CONSTANT(
270         bool, value
271         = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type));
272     typedef mpl::bool_<value> type;
273 };
274 
275 template <class T>
276 struct is_pointer_to_function
277     : mpl::if_<is_pointer<T>, is_pointer_to_function_aux<T>, mpl::bool_<false> >::type
278 {
279     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_function,(T))
280 };
281 
282 struct false_helper1
283 {
284     template <class T>
285     struct apply : mpl::false_
286     {
287     };
288 };
289 
290 template <typename V>
291 typename is_const_help<V>::type reference_to_const_helper(V&);
292 outer_no_type
293 reference_to_const_helper(...);
294 
295 struct true_helper1
296 {
297     template <class T>
298     struct apply
299     {
300         static T t;
301         BOOST_STATIC_CONSTANT(
302             bool, value
303             = sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type));
304         typedef mpl::bool_<value> type;
305     };
306 };
307 
308 template <bool ref = true>
309 struct is_reference_to_const_helper1 : true_helper1
310 {
311 };
312 
313 template <>
314 struct is_reference_to_const_helper1<false> : false_helper1
315 {
316 };
317 
318 
319 template <class T>
320 struct is_reference_to_const
321     : is_reference_to_const_helper1<is_reference<T>::value>::template apply<T>
322 {
323 };
324 
325 
326 template <bool ref = true>
327 struct is_reference_to_non_const_helper1
328 {
329     template <class T>
330     struct apply
331     {
332         static T t;
333         BOOST_STATIC_CONSTANT(
334             bool, value
335             = sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type));
336 
337         typedef mpl::bool_<value> type;
338     };
339 };
340 
341 template <>
342 struct is_reference_to_non_const_helper1<false> : false_helper1
343 {
344 };
345 
346 
347 template <class T>
348 struct is_reference_to_non_const
349     : is_reference_to_non_const_helper1<is_reference<T>::value>::template apply<T>
350 {
351     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_non_const,(T))
352 };
353 
354 
355 template <typename V>
356 typename is_volatile_help<V>::type reference_to_volatile_helper(V&);
357 outer_no_type
358 reference_to_volatile_helper(...);
359 
360 template <bool ref = true>
361 struct is_reference_to_volatile_helper1
362 {
363     template <class T>
364     struct apply
365     {
366         static T t;
367         BOOST_STATIC_CONSTANT(
368             bool, value
369             = sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type));
370         typedef mpl::bool_<value> type;
371     };
372 };
373 
374 template <>
375 struct is_reference_to_volatile_helper1<false> : false_helper1
376 {
377 };
378 
379 
380 template <class T>
381 struct is_reference_to_volatile
382     : is_reference_to_volatile_helper1<is_reference<T>::value>::template apply<T>
383 {
384 };
385 
386 template <typename V>
387 typename is_pointer_help<V>::type reference_to_pointer_helper(V&);
388 outer_no_type reference_to_pointer_helper(...);
389 
390 template <class T>
391 struct reference_to_pointer_impl
392 {
393     static T t;
394     BOOST_STATIC_CONSTANT(
395         bool, value
396         = (sizeof((reference_to_pointer_helper)(t)) == sizeof(inner_yes_type))
397         );
398 
399     typedef mpl::bool_<value> type;
400 };
401 
402 template <class T>
403 struct is_reference_to_pointer
404   : mpl::eval_if<is_reference<T>, reference_to_pointer_impl<T>, mpl::false_>::type
405 {
406     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_pointer,(T))
407 };
408 
409 template <class T>
410 struct is_reference_to_function_pointer
411   : mpl::eval_if<is_reference<T>, is_pointer_to_function_aux<T>, mpl::false_>::type
412 {
413     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_function_pointer,(T))
414 };
415 
416 
417 template <class T>
418 struct is_member_function_pointer_help
419     : mpl::if_<is_member_function_pointer<T>, inner_yes_type, inner_no_type>
420 {};
421 
422 template <typename V>
423 typename is_member_function_pointer_help<V>::type member_function_pointer_helper(V&);
424 outer_no_type member_function_pointer_helper(...);
425 
426 template <class T>
427 struct is_pointer_to_member_function_aux
428 {
429     static T t;
430     BOOST_STATIC_CONSTANT(
431         bool, value
432         = sizeof((member_function_pointer_helper)(t)) == sizeof(inner_yes_type));
433     typedef mpl::bool_<value> type;
434 };
435 
436 template <class T>
437 struct is_reference_to_member_function_pointer
438     : mpl::if_<
439         is_reference<T>
440         , is_pointer_to_member_function_aux<T>
441         , mpl::bool_<false>
442      >::type
443 {
444     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
445 };
446 
447 template <typename V>
448 typename is_class_help<V>::type reference_to_class_helper(V const volatile&);
449 outer_no_type reference_to_class_helper(...);
450 
451 template <class T>
452 struct is_reference_to_class
453 {
454     static T t;
455     BOOST_STATIC_CONSTANT(
456         bool, value
457         = (is_reference<T>::value
458            & (sizeof(reference_to_class_helper(t)) == sizeof(inner_yes_type)))
459         );
460     typedef mpl::bool_<value> type;
461     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
462 };
463 
464 template <typename V>
465 typename is_class_help<V>::type pointer_to_class_helper(V const volatile*);
466 outer_no_type pointer_to_class_helper(...);
467 
468 template <class T>
469 struct is_pointer_to_class
470 {
471     static T t;
472     BOOST_STATIC_CONSTANT(
473         bool, value
474         = (is_pointer<T>::value
475            && sizeof(pointer_to_class_helper(t)) == sizeof(inner_yes_type))
476         );
477     typedef mpl::bool_<value> type;
478 };
479 #  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
480 
481 }
482 
483 using namespace indirect_traits;
484 
485 }} // namespace boost::python::detail
486 
487 #endif // INDIRECT_TRAITS_DWA2002131_HPP
488