is_convertible.hpp
Go to the documentation of this file.
1 
2 // Copyright 2000 John Maddock (john@johnmaddock.co.uk)
3 // Copyright 2000 Jeremy Siek (jsiek@lsc.nd.edu)
4 // Copyright 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
5 //
6 // Use, modification and distribution are subject to the Boost Software License,
7 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
8 // http://www.boost.org/LICENSE_1_0.txt).
9 //
10 // See http://www.boost.org/libs/type_traits for most recent version including documentation.
11 
12 #ifndef BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED
13 #define BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED
14 
17 #ifndef BOOST_IS_CONVERTIBLE
23 #if !defined(BOOST_NO_IS_ABSTRACT)
25 #endif
29 
30 #if defined(__MWERKS__)
32 #endif
33 #if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
35 #endif
36 #elif defined(BOOST_MSVC) || defined(BOOST_INTEL)
39 #endif // BOOST_IS_CONVERTIBLE
40 
41 namespace boost {
42 
43 #ifndef BOOST_IS_CONVERTIBLE
44 
45 // is one type convertible to another?
46 //
47 // there are multiple versions of the is_convertible
48 // template, almost every compiler seems to require its
49 // own version.
50 //
51 // Thanks to Andrei Alexandrescu for the original version of the
52 // conversion detection technique!
53 //
54 
55 namespace detail {
56 
57 #if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !(defined(BOOST_GCC) && (BOOST_GCC < 40700))
58 
59  // This is a C++11 conforming version, place this first and use it wherever possible:
60 
61 # define BOOST_TT_CXX11_IS_CONVERTIBLE
62 
63  template <class A, class B, class C>
64  struct or_helper
65  {
66  static const bool value = (A::value || B::value || C::value);
67  };
68 
69  template<typename From, typename To, bool b = or_helper<boost::is_void<From>, boost::is_function<To>, boost::is_array<To> >::value>
71  {
72  // Nothing converts to function or array, but void converts to void:
73  static const bool value = is_void<To>::value;
74  };
75 
76  template<typename From, typename To>
77  class is_convertible_basic_impl<From, To, false>
78  {
79  typedef char one;
80  typedef int two;
81 
82  template<typename To1>
83  static void test_aux(To1);
84 
85  template<typename From1, typename To1>
86  static decltype(test_aux<To1>(boost::declval<From1>()), one()) test(int);
87 
88  template<typename, typename>
89  static two test(...);
90 
91  public:
92  static const bool value = sizeof(test<From, To>(0)) == 1;
93  };
94 
95 #elif defined(__BORLANDC__) && (__BORLANDC__ < 0x560)
96 //
97 // special version for Borland compilers
98 // this version breaks when used for some
99 // UDT conversions:
100 //
101 template <typename From, typename To>
102 struct is_convertible_impl
103 {
104 #pragma option push -w-8074
105  // This workaround for Borland breaks the EDG C++ frontend,
106  // so we only use it for Borland.
107  template <typename T> struct checker
108  {
109  static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...);
111  };
112 
113  static typename add_lvalue_reference<From>::type _m_from;
114  static bool const value = sizeof( checker<To>::_m_check(_m_from) )
115  == sizeof(::boost::type_traits::yes_type);
116 #pragma option pop
117 };
118 
119 #elif defined(__GNUC__) || defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
120 // special version for gcc compiler + recent Borland versions
121 // note that this does not pass UDT's through (...)
122 
123 struct any_conversion
124 {
125  template <typename T> any_conversion(const volatile T&);
126  template <typename T> any_conversion(const T&);
127  template <typename T> any_conversion(volatile T&);
128  template <typename T> any_conversion(T&);
129 };
130 
131 template <typename T> struct checker
132 {
133  static boost::type_traits::no_type _m_check(any_conversion ...);
134  static boost::type_traits::yes_type _m_check(T, int);
135 };
136 
137 template <typename From, typename To>
139 {
140  typedef typename add_lvalue_reference<From>::type lvalue_type;
141  typedef typename add_rvalue_reference<From>::type rvalue_type;
142  static lvalue_type _m_from;
143 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6)))
144  static bool const value =
145  sizeof( boost::detail::checker<To>::_m_check(static_cast<rvalue_type>(_m_from), 0) )
146  == sizeof(::boost::type_traits::yes_type);
147 #else
148  static bool const value =
149  sizeof( boost::detail::checker<To>::_m_check(_m_from, 0) )
150  == sizeof(::boost::type_traits::yes_type);
151 #endif
152 };
153 
154 #elif (defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 245) && !defined(__ICL)) \
155  || defined(__IBMCPP__) || defined(__HP_aCC)
156 //
157 // This is *almost* an ideal world implementation as it doesn't rely
158 // on undefined behaviour by passing UDT's through (...).
159 // Unfortunately it doesn't quite pass all the tests for most compilers (sigh...)
160 // Enable this for your compiler if is_convertible_test.cpp will compile it...
161 //
162 // Note we do not enable this for VC7.1, because even though it passes all the
163 // type_traits tests it is known to cause problems when instantiation occurs
164 // deep within the instantiation tree :-(
165 //
166 struct any_conversion
167 {
168  template <typename T> any_conversion(const volatile T&);
169  template <typename T> any_conversion(const T&);
170  template <typename T> any_conversion(volatile T&);
171  // we need this constructor to catch references to functions
172  // (which can not be cv-qualified):
173  template <typename T> any_conversion(T&);
174 };
175 
176 template <typename From, typename To>
178 {
179  static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion ...);
181  typedef typename add_lvalue_reference<From>::type lvalue_type;
182  typedef typename add_rvalue_reference<From>::type rvalue_type;
183  static lvalue_type _m_from;
184 
185 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
187  sizeof( _m_check(static_cast<rvalue_type>(_m_from), 0) ) == sizeof(::boost::type_traits::yes_type)
188  );
189 #else
191  sizeof( _m_check(_m_from, 0) ) == sizeof(::boost::type_traits::yes_type)
192  );
193 #endif
194 };
195 
196 #elif defined(__DMC__)
197 
198 struct any_conversion
199 {
200  template <typename T> any_conversion(const volatile T&);
201  template <typename T> any_conversion(const T&);
202  template <typename T> any_conversion(volatile T&);
203  // we need this constructor to catch references to functions
204  // (which can not be cv-qualified):
205  template <typename T> any_conversion(T&);
206 };
207 
208 template <typename From, typename To>
210 {
211  // Using '...' doesn't always work on Digital Mars. This version seems to.
212  template <class T>
213  static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion, float, T);
215  typedef typename add_lvalue_reference<From>::type lvalue_type;
216  typedef typename add_rvalue_reference<From>::type rvalue_type;
217  static lvalue_type _m_from;
218 
219  // Static constants sometime cause the conversion of _m_from to To to be
220  // called. This doesn't happen with an enum.
221 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
222  enum { value =
223  sizeof( _m_check(static_cast<rvalue_type>(_m_from), 0, 0) ) == sizeof(::boost::type_traits::yes_type)
224  };
225 #else
226  enum { value =
227  sizeof( _m_check(_m_from, 0, 0) ) == sizeof(::boost::type_traits::yes_type)
228  };
229 #endif
230 };
231 
232 #elif defined(__MWERKS__)
233 //
234 // CW works with the technique implemented above for EDG, except when From
235 // is a function type (or a reference to such a type), in which case
236 // any_conversion won't be accepted as a valid conversion. We detect this
237 // exceptional situation and channel it through an alternative algorithm.
238 //
239 
240 template <typename From, typename To,bool FromIsFunctionRef>
241 struct is_convertible_basic_impl_aux;
242 
243 struct any_conversion
244 {
245  template <typename T> any_conversion(const volatile T&);
246  template <typename T> any_conversion(const T&);
247  template <typename T> any_conversion(volatile T&);
248  template <typename T> any_conversion(T&);
249 };
250 
251 template <typename From, typename To>
252 struct is_convertible_basic_impl_aux<From,To,false /*FromIsFunctionRef*/>
253 {
254  static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion ...);
256  typedef typename add_lvalue_reference<From>::type lvalue_type;
257  typedef typename add_rvalue_reference<From>::type rvalue_type;
258  static lvalue_type _m_from;
259 
260 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
262  sizeof( _m_check(static_cast<rvalue_type>(_m_from), 0) ) == sizeof(::boost::type_traits::yes_type)
263  );
264 #else
266  sizeof( _m_check(_m_from, 0) ) == sizeof(::boost::type_traits::yes_type)
267  );
268 #endif
269 };
270 
271 template <typename From, typename To>
272 struct is_convertible_basic_impl_aux<From,To,true /*FromIsFunctionRef*/>
273 {
274  static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...);
276  typedef typename add_lvalue_reference<From>::type lvalue_type;
277  typedef typename add_rvalue_reference<From>::type rvalue_type;
278  static lvalue_type _m_from;
279 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
281  sizeof( _m_check(static_cast<rvalue_type>(_m_from)) ) == sizeof(::boost::type_traits::yes_type)
282  );
283 #else
285  sizeof( _m_check(_m_from) ) == sizeof(::boost::type_traits::yes_type)
286  );
287 #endif
288 };
289 
290 template <typename From, typename To>
292  is_convertible_basic_impl_aux<
293  From,To,
294  ::boost::is_function<typename ::boost::remove_reference<From>::type>::value
295  >
296 {};
297 
298 #else
299 //
300 // This version seems to work pretty well for a wide spectrum of compilers,
301 // however it does rely on undefined behaviour by passing UDT's through (...).
302 //
303 
304 //Workaround for old compilers like MSVC 7.1 to avoid
305 //forming a reference to an array of unknown bound
306 template <typename From>
307 struct is_convertible_basic_impl_add_lvalue_reference
308  : add_lvalue_reference<From>
309 {};
310 
311 template <typename From>
312 struct is_convertible_basic_impl_add_lvalue_reference<From[]>
313 {
314  typedef From type [];
315 };
316 
317 template <typename From, typename To>
319 {
320  static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...);
323  static lvalue_type _m_from;
324 #ifdef BOOST_MSVC
325 #pragma warning(push)
326 #pragma warning(disable:4244)
327 #if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
328 #pragma warning(disable:6334)
329 #endif
330 #endif
331 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
332  typedef typename add_rvalue_reference<From>::type rvalue_type;
334  sizeof( _m_check(static_cast<rvalue_type>(_m_from)) ) == sizeof(::boost::type_traits::yes_type)
335  );
336 #else
338  sizeof( _m_check(_m_from) ) == sizeof(::boost::type_traits::yes_type)
339  );
340 #endif
341 #ifdef BOOST_MSVC
342 #pragma warning(pop)
343 #endif
344 };
345 
346 #endif // is_convertible_impl
347 
348 #if defined(__DMC__)
349 // As before, a static constant sometimes causes errors on Digital Mars.
350 template <typename From, typename To>
351 struct is_convertible_impl
352 {
353  enum {
355  };
356 };
357 #elif !defined(__BORLANDC__) || __BORLANDC__ > 0x551
358 template <typename From, typename To>
360 {
362 };
363 #endif
364 
365 template <bool trivial1, bool trivial2, bool abstract_target>
367 {
368  template <class From, class To>
369  struct rebind
370  {
372  };
373 };
374 
375 template <>
376 struct is_convertible_impl_select<true, true, false>
377 {
378  template <class From, class To>
379  struct rebind
380  {
381  typedef true_type type;
382  };
383 };
384 
385 template <>
386 struct is_convertible_impl_select<false, false, true>
387 {
388  template <class From, class To>
389  struct rebind
390  {
391  typedef false_type type;
392  };
393 };
394 
395 template <>
396 struct is_convertible_impl_select<true, false, true>
397 {
398  template <class From, class To>
399  struct rebind
400  {
401  typedef false_type type;
402  };
403 };
404 
405 template <typename From, typename To>
407 {
408 #if !BOOST_WORKAROUND(__HP_aCC, < 60700)
412 #if !defined(BOOST_NO_IS_ABSTRACT) && !defined(BOOST_TT_CXX11_IS_CONVERTIBLE)
413  // We need to filter out abstract types, only if we don't have a strictly conforming C++11 version:
415 #else
416  false
417 #endif
419 #else
421 #endif
422  typedef typename selector::template rebind<From, To> isc_binder;
423  typedef typename isc_binder::type type;
424 };
425 
426 template <typename From, typename To>
428  : public is_convertible_impl_dispatch_base<From, To>::type
429 {};
430 
431 //
432 // Now add the full and partial specialisations
433 // for void types, these are common to all the
434 // implementation above:
435 //
436 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
437 
438 template <> struct is_convertible_impl_dispatch<void, void> : public true_type{};
439 template <> struct is_convertible_impl_dispatch<void, void const> : public true_type{};
440 template <> struct is_convertible_impl_dispatch<void, void const volatile> : public true_type{};
441 template <> struct is_convertible_impl_dispatch<void, void volatile> : public true_type{};
442 
443 template <> struct is_convertible_impl_dispatch<void const, void> : public true_type{};
444 template <> struct is_convertible_impl_dispatch<void const, void const> : public true_type{};
445 template <> struct is_convertible_impl_dispatch<void const, void const volatile> : public true_type{};
446 template <> struct is_convertible_impl_dispatch<void const, void volatile> : public true_type{};
447 
448 template <> struct is_convertible_impl_dispatch<void const volatile, void> : public true_type{};
449 template <> struct is_convertible_impl_dispatch<void const volatile, void const> : public true_type{};
450 template <> struct is_convertible_impl_dispatch<void const volatile, void const volatile> : public true_type{};
451 template <> struct is_convertible_impl_dispatch<void const volatile, void volatile> : public true_type{};
452 
453 template <> struct is_convertible_impl_dispatch<void volatile, void> : public true_type{};
454 template <> struct is_convertible_impl_dispatch<void volatile, void const> : public true_type{};
455 template <> struct is_convertible_impl_dispatch<void volatile, void const volatile> : public true_type{};
456 template <> struct is_convertible_impl_dispatch<void volatile, void volatile> : public true_type{};
457 
458 #else
459 template <> struct is_convertible_impl_dispatch<void, void> : public true_type{};
460 #endif // BOOST_NO_CV_VOID_SPECIALIZATIONS
461 
462 template <class To> struct is_convertible_impl_dispatch<void, To> : public false_type{};
463 template <class From> struct is_convertible_impl_dispatch<From, void> : public false_type{};
464 
465 #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
466 template <class To> struct is_convertible_impl_dispatch<void const, To> : public false_type{};
467 template <class From> struct is_convertible_impl_dispatch<From, void const> : public false_type{};
468 template <class To> struct is_convertible_impl_dispatch<void const volatile, To> : public false_type{};
469 template <class From> struct is_convertible_impl_dispatch<From, void const volatile> : public false_type{};
470 template <class To> struct is_convertible_impl_dispatch<void volatile, To> : public false_type{};
471 template <class From> struct is_convertible_impl_dispatch<From, void volatile> : public false_type{};
472 #endif
473 
474 } // namespace detail
475 
476 template <class From, class To>
477 struct is_convertible : public integral_constant<bool, ::boost::detail::is_convertible_impl_dispatch<From, To>::value> {};
478 
479 #else
480 
481 template <class From, class To>
482 struct is_convertible : public integral_constant<bool, BOOST_IS_CONVERTIBLE(From, To)> {};
483 
484 #endif
485 
486 } // namespace boost
487 
488 #endif // BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED
typedef void(APIENTRY *GLDEBUGPROC)(GLenum source
BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE.
GLfloat value
boost::add_reference< T >::type type
static const int one
#define BOOST_TT_DECL
const char * detail
GLenum type
is_convertible_impl_select< ::boost::is_arithmetic< From >::value,::boost::is_arithmetic< To >::value, false > selector
#define BOOST_STATIC_CONSTANT(type, assignment)
Definition: suffix.hpp:394
boost::type_traits_detail::add_rvalue_reference_imp< T >::type type
selector::template rebind< From, To > isc_binder


librealsense2
Author(s): Sergey Dorodnicov , Doron Hirshberg , Mark Horn , Reagan Lopez , Itay Carpis
autogenerated on Mon May 3 2021 02:47:17