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> 10 #include <boost/type_traits/detail/config.hpp> 11 12 // cannot include this header without getting warnings of the kind: 13 // gcc: 14 // warning: value computed is not used 15 // warning: comparison between signed and unsigned integer expressions 16 // msvc: 17 // warning C4018: '<' : signed/unsigned mismatch 18 // warning C4244: '+=' : conversion from 'double' to 'char', possible loss of data 19 // warning C4547: '*' : operator before comma has no effect; expected operator with side-effect 20 // warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning) 21 // warning C4804: '<' : unsafe use of type 'bool' in operation 22 // warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation 23 // cannot find another implementation -> declared as system header to suppress these warnings. 24 #if defined(__GNUC__) 25 # pragma GCC system_header 26 #elif defined(BOOST_MSVC) 27 # pragma warning ( push ) 28 # pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913 4133) 29 # if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000) 30 # pragma warning ( disable : 6334) 31 # endif 32 #endif 33 34 #if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION) 35 36 #include <boost/type_traits/integral_constant.hpp> 37 #include <boost/type_traits/make_void.hpp> 38 #include <boost/type_traits/is_convertible.hpp> 39 #include <boost/type_traits/is_void.hpp> 40 #include <boost/type_traits/add_reference.hpp> 41 #include <utility> 42 43 namespace boost 44 { 45 46 namespace binary_op_detail { 47 48 struct dont_care; 49 50 template <class T, class U, class Ret, class = void> 51 struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) : public boost::false_type {}; 52 53 template <class T, class U, class Ret> 54 struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp)<T, U, Ret, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())>::type> 55 : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>()), Ret>::value> {}; 56 57 template <class T, class U, class = void > 58 struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) : public boost::false_type {}; 59 60 template <class T, class U> 61 struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp)<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())>::type> 62 : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())>::value> {}; 63 64 template <class T, class U, class = void> 65 struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) : public boost::false_type {}; 66 67 template <class T, class U> 68 struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp)<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())>::type> 69 : public boost::true_type {}; 70 71 } 72 73 template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care> 74 struct BOOST_TT_TRAIT_NAME : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) <T, U, Ret> {}; 75 template <class T, class U> 76 struct BOOST_TT_TRAIT_NAME<T, U, void> : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) <T, U> {}; 77 template <class T, class U> 78 struct BOOST_TT_TRAIT_NAME<T, U, boost::binary_op_detail::dont_care> : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) <T, U> {}; 79 80 81 } 82 83 #else 84 85 #include <boost/type_traits/detail/yes_no_type.hpp> 86 #include <boost/type_traits/integral_constant.hpp> 87 #include <boost/type_traits/is_base_of.hpp> 88 #include <boost/type_traits/is_const.hpp> 89 #include <boost/type_traits/is_convertible.hpp> 90 #include <boost/type_traits/is_fundamental.hpp> 91 #include <boost/type_traits/is_integral.hpp> 92 #include <boost/type_traits/is_pointer.hpp> 93 #include <boost/type_traits/is_same.hpp> 94 #include <boost/type_traits/is_void.hpp> 95 #include <boost/type_traits/remove_cv.hpp> 96 #include <boost/type_traits/remove_pointer.hpp> 97 #include <boost/type_traits/remove_reference.hpp> 98 #include <boost/type_traits/detail/is_likely_lambda.hpp> 99 100 namespace boost { 101 namespace detail { 102 103 // This namespace ensures that argument-dependent name lookup does not mess things up. 104 namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) { 105 106 // 1. a function to have an instance of type T without requiring T to be default 107 // constructible 108 template <typename T> T &make(); 109 110 111 // 2. we provide our operator definition for types that do not have one already 112 113 // a type returned from operator BOOST_TT_TRAIT_OP when no such operator is 114 // found in the type's own namespace (our own operator is used) so that we have 115 // a means to know that our operator was used 116 struct no_operator { }; 117 118 // this class allows implicit conversions and makes the following operator 119 // definition less-preferred than any other such operators that might be found 120 // via argument-dependent name lookup 121 struct any { template <class T> any(T const&); }; 122 123 // when operator BOOST_TT_TRAIT_OP is not available, this one is used 124 no_operator operator BOOST_TT_TRAIT_OP (const any&, const any&); 125 126 127 // 3. checks if the operator returns void or not 128 // conditions: Lhs!=void and Rhs!=void 129 130 // we first redefine "operator," so that we have no compilation error if 131 // operator BOOST_TT_TRAIT_OP returns void and we can use the return type of 132 // (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) to deduce if 133 // operator BOOST_TT_TRAIT_OP returns void or not: 134 // - operator BOOST_TT_TRAIT_OP returns void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t 135 // - operator BOOST_TT_TRAIT_OP returns !=void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int 136 struct returns_void_t { }; 137 template <typename T> int operator,(const T&, returns_void_t); 138 template <typename T> int operator,(const volatile T&, returns_void_t); 139 140 // this intermediate trait has member value of type bool: 141 // - value==true -> operator BOOST_TT_TRAIT_OP returns void 142 // - value==false -> operator BOOST_TT_TRAIT_OP does not return void 143 template < typename Lhs, typename Rhs > 144 struct operator_returns_void { 145 // overloads of function returns_void make the difference 146 // yes_type and no_type have different size by construction 147 static ::boost::type_traits::yes_type returns_void(returns_void_t); 148 static ::boost::type_traits::no_type returns_void(int); 149 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()))))); 150 }; 151 152 153 // 4. checks if the return type is Ret or Ret==dont_care 154 // conditions: Lhs!=void and Rhs!=void 155 156 struct dont_care { }; 157 158 template < typename Lhs, typename Rhs, typename Ret, bool Returns_void > 159 struct operator_returns_Ret; 160 161 template < typename Lhs, typename Rhs > 162 struct operator_returns_Ret < Lhs, Rhs, dont_care, true > { 163 BOOST_STATIC_CONSTANT(bool, value = true); 164 }; 165 166 template < typename Lhs, typename Rhs > 167 struct operator_returns_Ret < Lhs, Rhs, dont_care, false > { 168 BOOST_STATIC_CONSTANT(bool, value = true); 169 }; 170 171 template < typename Lhs, typename Rhs > 172 struct operator_returns_Ret < Lhs, Rhs, void, true > { 173 BOOST_STATIC_CONSTANT(bool, value = true); 174 }; 175 176 template < typename Lhs, typename Rhs > 177 struct operator_returns_Ret < Lhs, Rhs, void, false > { 178 BOOST_STATIC_CONSTANT(bool, value = false); 179 }; 180 181 template < typename Lhs, typename Rhs, typename Ret > 182 struct operator_returns_Ret < Lhs, Rhs, Ret, true > { 183 BOOST_STATIC_CONSTANT(bool, value = false); 184 }; 185 186 // otherwise checks if it is convertible to Ret using the sizeof trick 187 // based on overload resolution 188 // condition: Ret!=void and Ret!=dont_care and the operator does not return void 189 template < typename Lhs, typename Rhs, typename Ret > 190 struct operator_returns_Ret < Lhs, Rhs, Ret, false > { 191 static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret 192 static ::boost::type_traits::no_type is_convertible_to_Ret(...); // this version is used otherwise 193 194 BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_Ret(make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>()))==sizeof(::boost::type_traits::yes_type))); 195 }; 196 197 198 // 5. checks for operator existence 199 // condition: Lhs!=void and Rhs!=void 200 201 // checks if our definition of operator BOOST_TT_TRAIT_OP is used or an other 202 // existing one; 203 // this is done with redefinition of "operator," that returns no_operator or has_operator 204 struct has_operator { }; 205 no_operator operator,(no_operator, has_operator); 206 207 template < typename Lhs, typename Rhs > 208 struct operator_exists { 209 static ::boost::type_traits::yes_type s_check(has_operator); // this version is preferred when operator exists 210 static ::boost::type_traits::no_type s_check(no_operator); // this version is used otherwise 211 212 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))); 213 }; 214 215 216 // 6. main trait: to avoid any compilation error, this class behaves 217 // differently when operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the 218 // standard. 219 // Forbidden_if is a bool that is: 220 // - true when the operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the standard 221 // (would yield compilation error if used) 222 // - false otherwise 223 template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if > 224 struct trait_impl1; 225 226 template < typename Lhs, typename Rhs, typename Ret > 227 struct trait_impl1 < Lhs, Rhs, Ret, true > { 228 BOOST_STATIC_CONSTANT(bool, value = false); 229 }; 230 231 template < typename Lhs, typename Rhs, typename Ret > 232 struct trait_impl1 < Lhs, Rhs, Ret, false > { 233 BOOST_STATIC_CONSTANT(bool, 234 value = (operator_exists < Lhs, Rhs >::value && operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value)); 235 }; 236 237 // some specializations needs to be declared for the special void case 238 template < typename Rhs, typename Ret > 239 struct trait_impl1 < void, Rhs, Ret, false > { 240 BOOST_STATIC_CONSTANT(bool, value = false); 241 }; 242 243 template < typename Lhs, typename Ret > 244 struct trait_impl1 < Lhs, void, Ret, false > { 245 BOOST_STATIC_CONSTANT(bool, value = false); 246 }; 247 248 template < typename Ret > 249 struct trait_impl1 < void, void, Ret, false > { 250 BOOST_STATIC_CONSTANT(bool, value = false); 251 }; 252 253 // defines some typedef for convenience 254 template < typename Lhs, typename Rhs, typename Ret > 255 struct trait_impl { 256 typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref; 257 typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref; 258 typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv; 259 typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv; 260 typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr; 261 typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr; 262 BOOST_STATIC_CONSTANT(bool, value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, BOOST_TT_FORBIDDEN_IF >::value)); 263 }; 264 265 } // namespace impl 266 } // namespace detail 267 268 // this is the accessible definition of the trait to end user 269 template <class Lhs, class Rhs=Lhs, class Ret=::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::dont_care> 270 struct BOOST_TT_TRAIT_NAME : public integral_constant<bool, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _impl)::trait_impl < Lhs, Rhs, Ret >::value)>{}; 271 272 } // namespace boost 273 274 #endif 275 276 #if defined(BOOST_MSVC) 277 # pragma warning ( pop ) 278 #endif 279 280