has_binary_operator.hpp
Go to the documentation of this file.
1 // (C) Copyright 2009-2011 Frederic Bron, Robert Stewart, Steven Watanabe & Roman Perepelitsa.
2 //
3 // Use, modification and distribution are subject to the Boost Software License,
4 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
5 // http://www.boost.org/LICENSE_1_0.txt).
6 //
7 // See http://www.boost.org/libs/type_traits for most recent version including documentation.
8 
9 #include <boost/config.hpp>
23 
24 // cannot include this header without getting warnings of the kind:
25 // gcc:
26 // warning: value computed is not used
27 // warning: comparison between signed and unsigned integer expressions
28 // msvc:
29 // warning C4018: '<' : signed/unsigned mismatch
30 // warning C4244: '+=' : conversion from 'double' to 'char', possible loss of data
31 // warning C4547: '*' : operator before comma has no effect; expected operator with side-effect
32 // warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning)
33 // warning C4804: '<' : unsafe use of type 'bool' in operation
34 // warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation
35 // cannot find another implementation -> declared as system header to suppress these warnings.
36 #if defined(__GNUC__)
37 # pragma GCC system_header
38 #elif defined(BOOST_MSVC)
39 # pragma warning ( push )
40 # pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913)
41 # if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
42 # pragma warning ( disable : 6334)
43 # endif
44 #endif
45 
46 namespace boost {
47 namespace detail {
48 
49 // This namespace ensures that argument-dependent name lookup does not mess things up.
50 namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
51 
52 // 1. a function to have an instance of type T without requiring T to be default
53 // constructible
54 template <typename T> T &make();
55 
56 
57 // 2. we provide our operator definition for types that do not have one already
58 
59 // a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
60 // found in the type's own namespace (our own operator is used) so that we have
61 // a means to know that our operator was used
62 struct no_operator { };
63 
64 // this class allows implicit conversions and makes the following operator
65 // definition less-preferred than any other such operators that might be found
66 // via argument-dependent name lookup
67 struct any { template <class T> any(T const&); };
68 
69 // when operator BOOST_TT_TRAIT_OP is not available, this one is used
70 no_operator operator BOOST_TT_TRAIT_OP (const any&, const any&);
71 
72 
73 // 3. checks if the operator returns void or not
74 // conditions: Lhs!=void and Rhs!=void
75 
76 // we first redefine "operator," so that we have no compilation error if
77 // operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
78 // (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) to deduce if
79 // operator BOOST_TT_TRAIT_OP returns void or not:
80 // - operator BOOST_TT_TRAIT_OP returns void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t
81 // - operator BOOST_TT_TRAIT_OP returns !=void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int
82 struct returns_void_t { };
83 template <typename T> int operator,(const T&, returns_void_t);
84 template <typename T> int operator,(const volatile T&, returns_void_t);
85 
86 // this intermediate trait has member value of type bool:
87 // - value==true -> operator BOOST_TT_TRAIT_OP returns void
88 // - value==false -> operator BOOST_TT_TRAIT_OP does not return void
89 template < typename Lhs, typename Rhs >
90 struct operator_returns_void {
91  // overloads of function returns_void make the difference
92  // yes_type and no_type have different size by construction
93  static ::boost::type_traits::yes_type returns_void(returns_void_t);
94  static ::boost::type_traits::no_type returns_void(int);
95  BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>(),returns_void_t())))));
96 };
97 
98 
99 // 4. checks if the return type is Ret or Ret==dont_care
100 // conditions: Lhs!=void and Rhs!=void
101 
102 struct dont_care { };
103 
104 template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
105 struct operator_returns_Ret;
106 
107 template < typename Lhs, typename Rhs >
108 struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
109  BOOST_STATIC_CONSTANT(bool, value = true);
110 };
111 
112 template < typename Lhs, typename Rhs >
113 struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
114  BOOST_STATIC_CONSTANT(bool, value = true);
115 };
116 
117 template < typename Lhs, typename Rhs >
118 struct operator_returns_Ret < Lhs, Rhs, void, true > {
119  BOOST_STATIC_CONSTANT(bool, value = true);
120 };
121 
122 template < typename Lhs, typename Rhs >
123 struct operator_returns_Ret < Lhs, Rhs, void, false > {
124  BOOST_STATIC_CONSTANT(bool, value = false);
125 };
126 
127 template < typename Lhs, typename Rhs, typename Ret >
128 struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
129  BOOST_STATIC_CONSTANT(bool, value = false);
130 };
131 
132 // otherwise checks if it is convertible to Ret using the sizeof trick
133 // based on overload resolution
134 // condition: Ret!=void and Ret!=dont_care and the operator does not return void
135 template < typename Lhs, typename Rhs, typename Ret >
136 struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
137  static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret
138  static ::boost::type_traits::no_type is_convertible_to_Ret(...); // this version is used otherwise
139 
140  BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_Ret(make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>()))==sizeof(::boost::type_traits::yes_type)));
141 };
142 
143 
144 // 5. checks for operator existence
145 // condition: Lhs!=void and Rhs!=void
146 
147 // checks if our definition of operator BOOST_TT_TRAIT_OP is used or an other
148 // existing one;
149 // this is done with redefinition of "operator," that returns no_operator or has_operator
150 struct has_operator { };
151 no_operator operator,(no_operator, has_operator);
152 
153 template < typename Lhs, typename Rhs >
154 struct operator_exists {
155  static ::boost::type_traits::yes_type s_check(has_operator); // this version is preferred when operator exists
156  static ::boost::type_traits::no_type s_check(no_operator); // this version is used otherwise
157 
158  BOOST_STATIC_CONSTANT(bool, value = (sizeof(s_check(((make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type)));
159 };
160 
161 
162 // 6. main trait: to avoid any compilation error, this class behaves
163 // differently when operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the
164 // standard.
165 // Forbidden_if is a bool that is:
166 // - true when the operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the standard
167 // (would yield compilation error if used)
168 // - false otherwise
169 template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
170 struct trait_impl1;
171 
172 template < typename Lhs, typename Rhs, typename Ret >
173 struct trait_impl1 < Lhs, Rhs, Ret, true > {
174  BOOST_STATIC_CONSTANT(bool, value = false);
175 };
176 
177 template < typename Lhs, typename Rhs, typename Ret >
178 struct trait_impl1 < Lhs, Rhs, Ret, false > {
180  value = (operator_exists < Lhs, Rhs >::value && operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value));
181 };
182 
183 // some specializations needs to be declared for the special void case
184 template < typename Rhs, typename Ret >
185 struct trait_impl1 < void, Rhs, Ret, false > {
186  BOOST_STATIC_CONSTANT(bool, value = false);
187 };
188 
189 template < typename Lhs, typename Ret >
190 struct trait_impl1 < Lhs, void, Ret, false > {
191  BOOST_STATIC_CONSTANT(bool, value = false);
192 };
193 
194 template < typename Ret >
195 struct trait_impl1 < void, void, Ret, false > {
196  BOOST_STATIC_CONSTANT(bool, value = false);
197 };
198 
199 // defines some typedef for convenience
200 template < typename Lhs, typename Rhs, typename Ret >
201 struct trait_impl {
209 };
210 
211 } // namespace impl
212 } // namespace detail
213 
214 // this is the accessible definition of the trait to end user
215 template <class Lhs, class Rhs=Lhs, class Ret=::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::dont_care>
216 struct BOOST_TT_TRAIT_NAME : public integral_constant<bool, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _impl)::trait_impl < Lhs, Rhs, Ret >::value)>{};
217 
218 } // namespace boost
219 
220 #if defined(BOOST_MSVC)
221 # pragma warning ( pop )
222 #endif
BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE.
GLfloat value
namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME, _impl)
#define BOOST_TT_TRAIT_OP
Definition: has_bit_and.hpp:13
const char * detail
GLenum type
#define BOOST_STATIC_CONSTANT(type, assignment)
Definition: suffix.hpp:394


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