1 2 #ifndef BOOST_MPL_HAS_XXX_HPP_INCLUDED 3 #define BOOST_MPL_HAS_XXX_HPP_INCLUDED 4 5 // Copyright Aleksey Gurtovoy 2002-2006 6 // Copyright David Abrahams 2002-2003 7 // Copyright Daniel Walker 2007 8 // 9 // Distributed under the Boost Software License, Version 1.0. 10 // (See accompanying file LICENSE_1_0.txt or copy at 11 // http://www.boost.org/LICENSE_1_0.txt) 12 // 13 // See http://www.boost.org/libs/mpl for documentation. 14 15 // $Id$ 16 // $Date$ 17 // $Revision$ 18 19 #include <boost/mpl/bool.hpp> 20 #include <boost/mpl/aux_/na_spec.hpp> 21 #include <boost/mpl/aux_/type_wrapper.hpp> 22 #include <boost/mpl/aux_/yes_no.hpp> 23 #include <boost/mpl/aux_/config/gcc.hpp> 24 #include <boost/mpl/aux_/config/has_xxx.hpp> 25 #include <boost/mpl/aux_/config/msvc_typename.hpp> 26 #include <boost/mpl/aux_/config/msvc.hpp> 27 #include <boost/mpl/aux_/config/static_constant.hpp> 28 #include <boost/mpl/aux_/config/workaround.hpp> 29 30 #include <boost/preprocessor/array/elem.hpp> 31 #include <boost/preprocessor/cat.hpp> 32 #include <boost/preprocessor/control/if.hpp> 33 #include <boost/preprocessor/repetition/enum_params.hpp> 34 #include <boost/preprocessor/repetition/enum_trailing_params.hpp> 35 36 #if BOOST_WORKAROUND( BOOST_BORLANDC, BOOST_TESTED_AT(0x590) ) 37 # include <boost/type_traits/is_class.hpp> 38 #endif 39 40 #if !defined(BOOST_MPL_CFG_NO_HAS_XXX) 41 42 # if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) 43 44 // agurt, 11/sep/02: MSVC-specific version (< 7.1), based on a USENET 45 // newsgroup's posting by John Madsen (comp.lang.c++.moderated, 46 // 1999-11-12 19:17:06 GMT); the code is _not_ standard-conforming, but 47 // it works way more reliably than the SFINAE-based implementation 48 49 // Modified dwa 8/Oct/02 to handle reference types. 50 51 # include <boost/mpl/if.hpp> 52 # include <boost/mpl/bool.hpp> 53 54 namespace boost { namespace mpl { namespace aux { 55 56 struct has_xxx_tag; 57 58 #if BOOST_WORKAROUND(BOOST_MSVC, == 1300) 59 template< typename U > struct msvc_incomplete_array 60 { 61 typedef char (&type)[sizeof(U) + 1]; 62 }; 63 #endif 64 65 template< typename T > 66 struct msvc_is_incomplete 67 { 68 // MSVC is capable of some kinds of SFINAE. If U is an incomplete 69 // type, it won't pick the second overload 70 static char tester(...); 71 72 #if BOOST_WORKAROUND(BOOST_MSVC, == 1300) 73 template< typename U > 74 static typename msvc_incomplete_array<U>::type tester(type_wrapper<U>); 75 #else 76 template< typename U > 77 static char (& tester(type_wrapper<U>) )[sizeof(U)+1]; 78 #endif 79 80 BOOST_STATIC_CONSTANT(bool, value = 81 sizeof(tester(type_wrapper<T>())) == 1 82 ); 83 }; 84 85 template<> 86 struct msvc_is_incomplete<int> 87 { 88 BOOST_STATIC_CONSTANT(bool, value = false); 89 }; 90 91 }}} 92 93 # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, default_) \ 94 template< typename T, typename name = ::boost::mpl::aux::has_xxx_tag > \ 95 struct BOOST_PP_CAT(trait,_impl) : T \ 96 { \ 97 static boost::mpl::aux::no_tag \ 98 test(void(*)(::boost::mpl::aux::has_xxx_tag)); \ 99 \ 100 static boost::mpl::aux::yes_tag test(...); \ 101 \ 102 BOOST_STATIC_CONSTANT(bool, value = \ 103 sizeof(test(static_cast<void(*)(name)>(0))) \ 104 != sizeof(boost::mpl::aux::no_tag) \ 105 ); \ 106 typedef boost::mpl::bool_<value> type; \ 107 }; \ 108 \ 109 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \ 110 struct trait \ 111 : boost::mpl::if_c< \ 112 boost::mpl::aux::msvc_is_incomplete<T>::value \ 113 , boost::mpl::bool_<false> \ 114 , BOOST_PP_CAT(trait,_impl)<T> \ 115 >::type \ 116 { \ 117 }; \ 118 \ 119 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, void) \ 120 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, bool) \ 121 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, char) \ 122 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed char) \ 123 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned char) \ 124 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed short) \ 125 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned short) \ 126 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed int) \ 127 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned int) \ 128 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed long) \ 129 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned long) \ 130 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, float) \ 131 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, double) \ 132 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, long double) \ 133 /**/ 134 135 # define BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, T) \ 136 template<> struct trait<T> \ 137 { \ 138 BOOST_STATIC_CONSTANT(bool, value = false); \ 139 typedef boost::mpl::bool_<false> type; \ 140 }; \ 141 /**/ 142 143 #if !defined(BOOST_NO_INTRINSIC_WCHAR_T) 144 # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, unused) \ 145 BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, unused) \ 146 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, wchar_t) \ 147 /**/ 148 #else 149 # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, unused) \ 150 BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, unused) \ 151 /**/ 152 #endif 153 154 155 // SFINAE-based implementations below are derived from a USENET newsgroup's 156 // posting by Rani Sharoni (comp.lang.c++.moderated, 2002-03-17 07:45:09 PST) 157 158 # elif BOOST_WORKAROUND(BOOST_MSVC, <= 1400) \ 159 || (BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1800)) && defined(__CUDACC__)) \ 160 || BOOST_WORKAROUND(__IBMCPP__, <= 700) 161 162 // MSVC 7.1 & MSVC 8.0 & VACPP 163 164 // agurt, 15/jun/05: replace overload-based SFINAE implementation with SFINAE 165 // applied to partial specialization to fix some apparently random failures 166 // (thanks to Daniel Wallin for researching this!) 167 168 # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ 169 template< typename T > \ 170 struct BOOST_PP_CAT(trait, _msvc_sfinae_helper) \ 171 { \ 172 typedef void type; \ 173 };\ 174 \ 175 template< typename T, typename U = void > \ 176 struct BOOST_PP_CAT(trait,_impl_) \ 177 { \ 178 BOOST_STATIC_CONSTANT(bool, value = false); \ 179 typedef boost::mpl::bool_<value> type; \ 180 }; \ 181 \ 182 template< typename T > \ 183 struct BOOST_PP_CAT(trait,_impl_)< \ 184 T \ 185 , typename BOOST_PP_CAT(trait, _msvc_sfinae_helper)< typename T::name >::type \ 186 > \ 187 { \ 188 BOOST_STATIC_CONSTANT(bool, value = true); \ 189 typedef boost::mpl::bool_<value> type; \ 190 }; \ 191 \ 192 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \ 193 struct trait \ 194 : BOOST_PP_CAT(trait,_impl_)<T> \ 195 { \ 196 }; \ 197 /**/ 198 199 # elif BOOST_WORKAROUND( BOOST_BORLANDC, BOOST_TESTED_AT(0x590) ) 200 201 # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_BCB_DEF(trait, trait_tester, name, default_) \ 202 template< typename T, bool IS_CLASS > \ 203 struct trait_tester \ 204 { \ 205 BOOST_STATIC_CONSTANT( bool, value = false ); \ 206 }; \ 207 template< typename T > \ 208 struct trait_tester< T, true > \ 209 { \ 210 struct trait_tester_impl \ 211 { \ 212 template < class U > \ 213 static int resolve( boost::mpl::aux::type_wrapper<U> const volatile * \ 214 , boost::mpl::aux::type_wrapper<typename U::name >* = 0 ); \ 215 static char resolve( ... ); \ 216 }; \ 217 typedef boost::mpl::aux::type_wrapper<T> t_; \ 218 BOOST_STATIC_CONSTANT( bool, value = ( sizeof( trait_tester_impl::resolve( static_cast< t_ * >(0) ) ) == sizeof(int) ) ); \ 219 }; \ 220 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \ 221 struct trait \ 222 { \ 223 BOOST_STATIC_CONSTANT( bool, value = (trait_tester< T, boost::is_class< T >::value >::value) ); \ 224 typedef boost::mpl::bool_< trait< T, fallback_ >::value > type; \ 225 }; 226 227 # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ 228 BOOST_MPL_HAS_XXX_TRAIT_NAMED_BCB_DEF( trait \ 229 , BOOST_PP_CAT(trait,_tester) \ 230 , name \ 231 , default_ ) \ 232 /**/ 233 234 # else // other SFINAE-capable compilers 235 236 # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ 237 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \ 238 struct trait \ 239 { \ 240 struct gcc_3_2_wknd \ 241 { \ 242 template< typename U > \ 243 static boost::mpl::aux::yes_tag test( \ 244 boost::mpl::aux::type_wrapper<U> const volatile* \ 245 , boost::mpl::aux::type_wrapper<BOOST_MSVC_TYPENAME U::name>* = 0 \ 246 ); \ 247 \ 248 static boost::mpl::aux::no_tag test(...); \ 249 }; \ 250 \ 251 typedef boost::mpl::aux::type_wrapper<T> t_; \ 252 BOOST_STATIC_CONSTANT(bool, value = \ 253 sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) \ 254 == sizeof(boost::mpl::aux::yes_tag) \ 255 ); \ 256 typedef boost::mpl::bool_<value> type; \ 257 }; \ 258 /**/ 259 260 # endif // BOOST_WORKAROUND(BOOST_MSVC, <= 1300) 261 262 263 #else // BOOST_MPL_CFG_NO_HAS_XXX 264 265 // placeholder implementation 266 267 # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ 268 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \ 269 struct trait \ 270 { \ 271 BOOST_STATIC_CONSTANT(bool, value = fallback_::value); \ 272 typedef fallback_ type; \ 273 }; \ 274 /**/ 275 276 #endif 277 278 #define BOOST_MPL_HAS_XXX_TRAIT_DEF(name) \ 279 BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(BOOST_PP_CAT(has_,name), name, false) \ 280 /**/ 281 282 283 #if !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE) 284 285 // Create a boolean Metafunction to detect a nested template 286 // member. This implementation is based on a USENET newsgroup's 287 // posting by Aleksey Gurtovoy (comp.lang.c++.moderated, 2002-03-19), 288 // Rani Sharoni's USENET posting cited above, the non-template has_xxx 289 // implementations above, and discussion on the Boost mailing list. 290 291 # if !defined(BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES) 292 # if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) 293 # define BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 1 294 # else 295 # define BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 0 296 # endif 297 # endif 298 299 # if !defined(BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION) 300 # if (defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)) 301 # define BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 1 302 # else 303 # define BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 0 304 # endif 305 # endif 306 307 # if !defined(BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE) 308 # if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) 309 # define BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 1 310 # else 311 # define BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 0 312 # endif 313 # endif 314 315 // NOTE: Many internal implementation macros take a Boost.Preprocessor 316 // array argument called args which is of the following form. 317 // ( 4, ( trait, name, max_arity, default_ ) ) 318 319 # define BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) \ 320 BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _introspect) \ 321 /**/ 322 323 # define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \ 324 BOOST_PP_CAT(BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _substitute), n) \ 325 /**/ 326 327 # define BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args) \ 328 BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _test) \ 329 /**/ 330 331 // Thanks to Guillaume Melquiond for pointing out the need for the 332 // "substitute" template as an argument to the overloaded test 333 // functions to get SFINAE to work for member templates with the 334 // correct name but different number of arguments. 335 # define BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE(z, n, args) \ 336 template< \ 337 template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), typename V) > class V \ 338 > \ 339 struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) { \ 340 }; \ 341 /**/ 342 343 # define BOOST_MPL_HAS_MEMBER_SUBSTITUTE(args, substitute_macro) \ 344 BOOST_PP_REPEAT( \ 345 BOOST_PP_ARRAY_ELEM(2, args) \ 346 , BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE \ 347 , args \ 348 ) \ 349 /**/ 350 351 # if !BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 352 # define BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \ 353 template< typename V > \ 354 static boost::mpl::aux::no_tag \ 355 BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)(...); \ 356 /**/ 357 # else 358 # define BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \ 359 static boost::mpl::aux::no_tag \ 360 BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)(...); \ 361 /**/ 362 # endif 363 364 # if !BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 365 # define BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT(z, n, args) \ 366 template< typename V > \ 367 static boost::mpl::aux::yes_tag \ 368 BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \ 369 boost::mpl::aux::type_wrapper< V > const volatile* \ 370 , BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) < \ 371 V::template BOOST_PP_ARRAY_ELEM(1, args) \ 372 >* = 0 \ 373 ); \ 374 /**/ 375 # define BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \ 376 BOOST_PP_REPEAT( \ 377 BOOST_PP_ARRAY_ELEM(2, args) \ 378 , BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT \ 379 , args \ 380 ) \ 381 /**/ 382 # else 383 # define BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \ 384 template< typename V > \ 385 static boost::mpl::aux::yes_tag \ 386 BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \ 387 V const volatile* \ 388 , member_macro(args, V, T)* = 0 \ 389 ); \ 390 /**/ 391 # endif 392 393 # if !BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 394 # define BOOST_MPL_HAS_MEMBER_TEST(args) \ 395 sizeof(BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< U >(0)) \ 396 == sizeof(boost::mpl::aux::yes_tag) \ 397 /**/ 398 # else 399 # if !BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 400 # define BOOST_MPL_HAS_MEMBER_TEST(args) \ 401 sizeof( \ 402 BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \ 403 static_cast< boost::mpl::aux::type_wrapper< U >* >(0) \ 404 ) \ 405 ) == sizeof(boost::mpl::aux::yes_tag) \ 406 /**/ 407 # else 408 # define BOOST_MPL_HAS_MEMBER_TEST(args) \ 409 sizeof( \ 410 BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \ 411 static_cast< U* >(0) \ 412 ) \ 413 ) == sizeof(boost::mpl::aux::yes_tag) \ 414 /**/ 415 # endif 416 # endif 417 418 # define BOOST_MPL_HAS_MEMBER_INTROSPECT( \ 419 args, substitute_macro, member_macro \ 420 ) \ 421 template< typename U > \ 422 struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) { \ 423 BOOST_MPL_HAS_MEMBER_SUBSTITUTE(args, substitute_macro) \ 424 BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \ 425 BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \ 426 BOOST_STATIC_CONSTANT( \ 427 bool, value = BOOST_MPL_HAS_MEMBER_TEST(args) \ 428 ); \ 429 typedef boost::mpl::bool_< value > type; \ 430 }; \ 431 /**/ 432 433 # define BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \ 434 args, introspect_macro, substitute_macro, member_macro \ 435 ) \ 436 template< \ 437 typename T \ 438 , typename fallback_ \ 439 = boost::mpl::bool_< BOOST_PP_ARRAY_ELEM(3, args) > \ 440 > \ 441 class BOOST_PP_ARRAY_ELEM(0, args) { \ 442 introspect_macro(args, substitute_macro, member_macro) \ 443 public: \ 444 static const bool value \ 445 = BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args)< T >::value; \ 446 typedef typename BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args)< \ 447 T \ 448 >::type type; \ 449 }; \ 450 /**/ 451 452 // BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE expands to the full 453 // implementation of the function-based metafunction. Compile with -E 454 // to see the preprocessor output for this macro. 455 # define BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE( \ 456 args, substitute_macro, member_macro \ 457 ) \ 458 BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \ 459 args \ 460 , BOOST_MPL_HAS_MEMBER_INTROSPECT \ 461 , substitute_macro \ 462 , member_macro \ 463 ) \ 464 /**/ 465 466 # if BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 467 468 # if !defined(BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE) 469 # if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) 470 # define BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE 1 471 # endif 472 # endif 473 474 # if !BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE 475 # define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ 476 args, n \ 477 ) \ 478 BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \ 479 /**/ 480 # else 481 # define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ 482 args, n \ 483 ) \ 484 BOOST_PP_CAT( \ 485 boost_mpl_has_xxx_ \ 486 , BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \ 487 ) \ 488 /**/ 489 # endif 490 491 # define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME( \ 492 args \ 493 ) \ 494 BOOST_PP_CAT( \ 495 BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ 496 args, 0 \ 497 ) \ 498 , _tag \ 499 ) \ 500 /**/ 501 502 # define BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \ 503 z, n, args \ 504 ) \ 505 template< \ 506 template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), typename U) > class U \ 507 > \ 508 struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ 509 args, n \ 510 ) { \ 511 typedef \ 512 BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args) \ 513 type; \ 514 }; \ 515 /**/ 516 517 # define BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \ 518 args, substitute_macro \ 519 ) \ 520 typedef void \ 521 BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args); \ 522 BOOST_PP_REPEAT( \ 523 BOOST_PP_ARRAY_ELEM(2, args) \ 524 , BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE_WITH_TEMPLATE_SFINAE \ 525 , args \ 526 ) \ 527 /**/ 528 529 # define BOOST_MPL_HAS_MEMBER_REJECT_WITH_TEMPLATE_SFINAE( \ 530 args, member_macro \ 531 ) \ 532 template< \ 533 typename U \ 534 , typename V \ 535 = BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args) \ 536 > \ 537 struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args) { \ 538 BOOST_STATIC_CONSTANT(bool, value = false); \ 539 typedef boost::mpl::bool_< value > type; \ 540 }; \ 541 /**/ 542 543 # define BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT_WITH_TEMPLATE_SFINAE( \ 544 z, n, args \ 545 ) \ 546 template< typename U > \ 547 struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< \ 548 U \ 549 , typename \ 550 BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ 551 args, n \ 552 )< \ 553 BOOST_MSVC_TYPENAME U::BOOST_PP_ARRAY_ELEM(1, args)< > \ 554 >::type \ 555 > { \ 556 BOOST_STATIC_CONSTANT(bool, value = true); \ 557 typedef boost::mpl::bool_< value > type; \ 558 }; \ 559 /**/ 560 561 # define BOOST_MPL_HAS_MEMBER_ACCEPT_WITH_TEMPLATE_SFINAE( \ 562 args, member_macro \ 563 ) \ 564 BOOST_PP_REPEAT( \ 565 BOOST_PP_ARRAY_ELEM(2, args) \ 566 , BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT_WITH_TEMPLATE_SFINAE \ 567 , args \ 568 ) \ 569 /**/ 570 571 # define BOOST_MPL_HAS_MEMBER_INTROSPECT_WITH_TEMPLATE_SFINAE( \ 572 args, substitute_macro, member_macro \ 573 ) \ 574 BOOST_MPL_HAS_MEMBER_REJECT_WITH_TEMPLATE_SFINAE(args, member_macro) \ 575 BOOST_MPL_HAS_MEMBER_ACCEPT_WITH_TEMPLATE_SFINAE(args, member_macro) \ 576 template< typename U > \ 577 struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) \ 578 : BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< U > { \ 579 }; \ 580 /**/ 581 582 // BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE expands to the full 583 // implementation of the template-based metafunction. Compile with -E 584 // to see the preprocessor output for this macro. 585 // 586 // Note that if BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE is 587 // defined BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE needs 588 // to be expanded at namespace level before 589 // BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE can be used. 590 # define BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE( \ 591 args, substitute_macro, member_macro \ 592 ) \ 593 BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \ 594 args, substitute_macro \ 595 ) \ 596 BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \ 597 args \ 598 , BOOST_MPL_HAS_MEMBER_INTROSPECT_WITH_TEMPLATE_SFINAE \ 599 , substitute_macro \ 600 , member_macro \ 601 ) \ 602 /**/ 603 604 # endif // BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 605 606 // Note: In the current implementation the parameter and access macros 607 // are no longer expanded. 608 # if !BOOST_WORKAROUND(BOOST_MSVC, <= 1400) 609 # define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \ 610 BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE( \ 611 ( 4, ( trait, name, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, default_ ) ) \ 612 , BOOST_MPL_HAS_MEMBER_TEMPLATE_SUBSTITUTE_PARAMETER \ 613 , BOOST_MPL_HAS_MEMBER_TEMPLATE_ACCESS \ 614 ) \ 615 /**/ 616 # else 617 # define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \ 618 BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE( \ 619 ( 4, ( trait, name, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, default_ ) ) \ 620 , BOOST_MPL_HAS_MEMBER_TEMPLATE_SUBSTITUTE_PARAMETER \ 621 , BOOST_MPL_HAS_MEMBER_TEMPLATE_ACCESS \ 622 ) \ 623 /**/ 624 # endif 625 626 #else // BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE 627 628 // placeholder implementation 629 630 # define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \ 631 template< typename T \ 632 , typename fallback_ = boost::mpl::bool_< default_ > > \ 633 struct trait { \ 634 BOOST_STATIC_CONSTANT(bool, value = fallback_::value); \ 635 typedef fallback_ type; \ 636 }; \ 637 /**/ 638 639 #endif // BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE 640 641 # define BOOST_MPL_HAS_XXX_TEMPLATE_DEF(name) \ 642 BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF( \ 643 BOOST_PP_CAT(has_, name), name, false \ 644 ) \ 645 /**/ 646 647 #endif // BOOST_MPL_HAS_XXX_HPP_INCLUDED 648