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: has_xxx.hpp 64146 2010-07-19 00:46:31Z djwalker $ 16 // $Date: 2010-07-18 17:46:31 -0700 (Sun, 18 Jul 2010) $ 17 // $Revision: 64146 $ 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( __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, BOOST_TESTED_AT(1400)) \ 159 || BOOST_WORKAROUND(__IBMCPP__, <= 700) 160 161 // MSVC 7.1+ & VACPP 162 163 // agurt, 15/jun/05: replace overload-based SFINAE implementation with SFINAE 164 // applied to partial specialization to fix some apparently random failures 165 // (thanks to Daniel Wallin for researching this!) 166 167 # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ 168 template< typename T > \ 169 struct BOOST_PP_CAT(trait, _msvc_sfinae_helper) \ 170 { \ 171 typedef void type; \ 172 };\ 173 \ 174 template< typename T, typename U = void > \ 175 struct BOOST_PP_CAT(trait,_impl_) \ 176 { \ 177 BOOST_STATIC_CONSTANT(bool, value = false); \ 178 typedef boost::mpl::bool_<value> type; \ 179 }; \ 180 \ 181 template< typename T > \ 182 struct BOOST_PP_CAT(trait,_impl_)< \ 183 T \ 184 , typename BOOST_PP_CAT(trait, _msvc_sfinae_helper)< typename T::name >::type \ 185 > \ 186 { \ 187 BOOST_STATIC_CONSTANT(bool, value = true); \ 188 typedef boost::mpl::bool_<value> type; \ 189 }; \ 190 \ 191 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \ 192 struct trait \ 193 : BOOST_PP_CAT(trait,_impl_)<T> \ 194 { \ 195 }; \ 196 /**/ 197 198 # elif BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x590) ) 199 200 # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_BCB_DEF(trait, trait_tester, name, default_) \ 201 template< typename T, bool IS_CLASS > \ 202 struct trait_tester \ 203 { \ 204 BOOST_STATIC_CONSTANT( bool, value = false ); \ 205 }; \ 206 template< typename T > \ 207 struct trait_tester< T, true > \ 208 { \ 209 struct trait_tester_impl \ 210 { \ 211 template < class U > \ 212 static int resolve( boost::mpl::aux::type_wrapper<U> const volatile * \ 213 , boost::mpl::aux::type_wrapper<typename U::name >* = 0 ); \ 214 static char resolve( ... ); \ 215 }; \ 216 typedef boost::mpl::aux::type_wrapper<T> t_; \ 217 BOOST_STATIC_CONSTANT( bool, value = ( sizeof( trait_tester_impl::resolve( static_cast< t_ * >(0) ) ) == sizeof(int) ) ); \ 218 }; \ 219 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \ 220 struct trait \ 221 { \ 222 BOOST_STATIC_CONSTANT( bool, value = (trait_tester< T, boost::is_class< T >::value >::value) ); \ 223 typedef boost::mpl::bool_< trait< T, fallback_ >::value > type; \ 224 }; 225 226 # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ 227 BOOST_MPL_HAS_XXX_TRAIT_NAMED_BCB_DEF( trait \ 228 , BOOST_PP_CAT(trait,_tester) \ 229 , name \ 230 , default_ ) \ 231 /**/ 232 233 # else // other SFINAE-capable compilers 234 235 # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ 236 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \ 237 struct trait \ 238 { \ 239 struct gcc_3_2_wknd \ 240 { \ 241 template< typename U > \ 242 static boost::mpl::aux::yes_tag test( \ 243 boost::mpl::aux::type_wrapper<U> const volatile* \ 244 , boost::mpl::aux::type_wrapper<BOOST_MSVC_TYPENAME U::name>* = 0 \ 245 ); \ 246 \ 247 static boost::mpl::aux::no_tag test(...); \ 248 }; \ 249 \ 250 typedef boost::mpl::aux::type_wrapper<T> t_; \ 251 BOOST_STATIC_CONSTANT(bool, value = \ 252 sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) \ 253 == sizeof(boost::mpl::aux::yes_tag) \ 254 ); \ 255 typedef boost::mpl::bool_<value> type; \ 256 }; \ 257 /**/ 258 259 # endif // BOOST_WORKAROUND(BOOST_MSVC, <= 1300) 260 261 262 #else // BOOST_MPL_CFG_NO_HAS_XXX 263 264 // placeholder implementation 265 266 # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ 267 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \ 268 struct trait \ 269 { \ 270 BOOST_STATIC_CONSTANT(bool, value = fallback_::value); \ 271 typedef fallback_ type; \ 272 }; \ 273 /**/ 274 275 #endif 276 277 #define BOOST_MPL_HAS_XXX_TRAIT_DEF(name) \ 278 BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(BOOST_PP_CAT(has_,name), name, false) \ 279 /**/ 280 281 282 #if !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE) 283 284 // Create a boolean Metafunction to detect a nested template 285 // member. This implementation is based on a USENET newsgroup's 286 // posting by Aleksey Gurtovoy (comp.lang.c++.moderated, 2002-03-19), 287 // Rani Sharoni's USENET posting cited above, the non-template has_xxx 288 // implementations above, and discussion on the Boost mailing list. 289 290 # if !defined(BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES) 291 # if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) 292 # define BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 1 293 # endif 294 # endif 295 296 # if !defined(BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION) 297 # if (defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)) 298 # define BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 1 299 # endif 300 # endif 301 302 # if !defined(BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE) 303 # if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) 304 # define BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 1 305 # endif 306 # endif 307 308 // NOTE: Many internal implementation macros take a Boost.Preprocessor 309 // array argument called args which is of the following form. 310 // ( 4, ( trait, name, max_arity, default_ ) ) 311 312 # define BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) \ 313 BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _introspect) \ 314 /**/ 315 316 # define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \ 317 BOOST_PP_CAT(BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _substitute), n) \ 318 /**/ 319 320 # define BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args) \ 321 BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _test) \ 322 /**/ 323 324 // Thanks to Guillaume Melquiond for pointing out the need for the 325 // "substitute" template as an argument to the overloaded test 326 // functions to get SFINAE to work for member templates with the 327 // correct name but different number of arguments. 328 # define BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE(z, n, args) \ 329 template< \ 330 template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), typename V) > class V \ 331 > \ 332 struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) { \ 333 }; \ 334 /**/ 335 336 # define BOOST_MPL_HAS_MEMBER_SUBSTITUTE(args, substitute_macro) \ 337 BOOST_PP_REPEAT( \ 338 BOOST_PP_ARRAY_ELEM(2, args) \ 339 , BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE \ 340 , args \ 341 ) \ 342 /**/ 343 344 # if !BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 345 # define BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \ 346 template< typename V > \ 347 static boost::mpl::aux::no_tag \ 348 BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)(...); \ 349 /**/ 350 # else 351 # define BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \ 352 static boost::mpl::aux::no_tag \ 353 BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)(...); \ 354 /**/ 355 # endif 356 357 # if !BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 358 # define BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT(z, n, args) \ 359 template< typename V > \ 360 static boost::mpl::aux::yes_tag \ 361 BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \ 362 boost::mpl::aux::type_wrapper< V > const volatile* \ 363 , BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) < \ 364 V::template BOOST_PP_ARRAY_ELEM(1, args) \ 365 >* = 0 \ 366 ); \ 367 /**/ 368 # define BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \ 369 BOOST_PP_REPEAT( \ 370 BOOST_PP_ARRAY_ELEM(2, args) \ 371 , BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT \ 372 , args \ 373 ) \ 374 /**/ 375 # else 376 # define BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \ 377 template< typename V > \ 378 static boost::mpl::aux::yes_tag \ 379 BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \ 380 V const volatile* \ 381 , member_macro(args, V, T)* = 0 \ 382 ); \ 383 /**/ 384 # endif 385 386 # if !BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 387 # define BOOST_MPL_HAS_MEMBER_TEST(args) \ 388 sizeof(BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< U >(0)) \ 389 == sizeof(boost::mpl::aux::yes_tag) \ 390 /**/ 391 # else 392 # if !BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 393 # define BOOST_MPL_HAS_MEMBER_TEST(args) \ 394 sizeof( \ 395 BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \ 396 static_cast< boost::mpl::aux::type_wrapper< U >* >(0) \ 397 ) \ 398 ) == sizeof(boost::mpl::aux::yes_tag) \ 399 /**/ 400 # else 401 # define BOOST_MPL_HAS_MEMBER_TEST(args) \ 402 sizeof( \ 403 BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( \ 404 static_cast< U* >(0) \ 405 ) \ 406 ) == sizeof(boost::mpl::aux::yes_tag) \ 407 /**/ 408 # endif 409 # endif 410 411 # define BOOST_MPL_HAS_MEMBER_INTROSPECT( \ 412 args, substitute_macro, member_macro \ 413 ) \ 414 template< typename U > \ 415 struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) { \ 416 BOOST_MPL_HAS_MEMBER_SUBSTITUTE(args, substitute_macro) \ 417 BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) \ 418 BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) \ 419 BOOST_STATIC_CONSTANT( \ 420 bool, value = BOOST_MPL_HAS_MEMBER_TEST(args) \ 421 ); \ 422 typedef boost::mpl::bool_< value > type; \ 423 }; \ 424 /**/ 425 426 # define BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \ 427 args, introspect_macro, substitute_macro, member_macro \ 428 ) \ 429 template< \ 430 typename T \ 431 , typename fallback_ \ 432 = boost::mpl::bool_< BOOST_PP_ARRAY_ELEM(3, args) > \ 433 > \ 434 class BOOST_PP_ARRAY_ELEM(0, args) { \ 435 introspect_macro(args, substitute_macro, member_macro) \ 436 public: \ 437 static const bool value \ 438 = BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args)< T >::value; \ 439 typedef typename BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args)< \ 440 T \ 441 >::type type; \ 442 }; \ 443 /**/ 444 445 // BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE expands to the full 446 // implementation of the function-based metafunction. Compile with -E 447 // to see the preprocessor output for this macro. 448 # define BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE( \ 449 args, substitute_macro, member_macro \ 450 ) \ 451 BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \ 452 args \ 453 , BOOST_MPL_HAS_MEMBER_INTROSPECT \ 454 , substitute_macro \ 455 , member_macro \ 456 ) \ 457 /**/ 458 459 # if BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 460 461 # if !defined(BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE) 462 # if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) 463 # define BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE 1 464 # endif 465 # endif 466 467 # if !BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE 468 # define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ 469 args, n \ 470 ) \ 471 BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \ 472 /**/ 473 # else 474 # define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ 475 args, n \ 476 ) \ 477 BOOST_PP_CAT( \ 478 boost_mpl_has_xxx_ \ 479 , BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \ 480 ) \ 481 /**/ 482 # endif 483 484 # define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME( \ 485 args \ 486 ) \ 487 BOOST_PP_CAT( \ 488 BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ 489 args, 0 \ 490 ) \ 491 , _tag \ 492 ) \ 493 /**/ 494 495 # define BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \ 496 z, n, args \ 497 ) \ 498 template< \ 499 template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), typename U) > class U \ 500 > \ 501 struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ 502 args, n \ 503 ) { \ 504 typedef \ 505 BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args) \ 506 type; \ 507 }; \ 508 /**/ 509 510 # define BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \ 511 args, substitute_macro \ 512 ) \ 513 typedef void \ 514 BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args); \ 515 BOOST_PP_REPEAT( \ 516 BOOST_PP_ARRAY_ELEM(2, args) \ 517 , BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE_WITH_TEMPLATE_SFINAE \ 518 , args \ 519 ) \ 520 /**/ 521 522 # define BOOST_MPL_HAS_MEMBER_REJECT_WITH_TEMPLATE_SFINAE( \ 523 args, member_macro \ 524 ) \ 525 template< \ 526 typename U \ 527 , typename V \ 528 = BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args) \ 529 > \ 530 struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args) { \ 531 BOOST_STATIC_CONSTANT(bool, value = false); \ 532 typedef boost::mpl::bool_< value > type; \ 533 }; \ 534 /**/ 535 536 # define BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT_WITH_TEMPLATE_SFINAE( \ 537 z, n, args \ 538 ) \ 539 template< typename U > \ 540 struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< \ 541 U \ 542 , typename \ 543 BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \ 544 args, n \ 545 )< \ 546 BOOST_MSVC_TYPENAME U::BOOST_PP_ARRAY_ELEM(1, args)< > \ 547 >::type \ 548 > { \ 549 BOOST_STATIC_CONSTANT(bool, value = true); \ 550 typedef boost::mpl::bool_< value > type; \ 551 }; \ 552 /**/ 553 554 # define BOOST_MPL_HAS_MEMBER_ACCEPT_WITH_TEMPLATE_SFINAE( \ 555 args, member_macro \ 556 ) \ 557 BOOST_PP_REPEAT( \ 558 BOOST_PP_ARRAY_ELEM(2, args) \ 559 , BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT_WITH_TEMPLATE_SFINAE \ 560 , args \ 561 ) \ 562 /**/ 563 564 # define BOOST_MPL_HAS_MEMBER_INTROSPECT_WITH_TEMPLATE_SFINAE( \ 565 args, substitute_macro, member_macro \ 566 ) \ 567 BOOST_MPL_HAS_MEMBER_REJECT_WITH_TEMPLATE_SFINAE(args, member_macro) \ 568 BOOST_MPL_HAS_MEMBER_ACCEPT_WITH_TEMPLATE_SFINAE(args, member_macro) \ 569 template< typename U > \ 570 struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) \ 571 : BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< U > { \ 572 }; \ 573 /**/ 574 575 // BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE expands to the full 576 // implementation of the template-based metafunction. Compile with -E 577 // to see the preprocessor output for this macro. 578 // 579 // Note that if BOOST_MPL_HAS_XXX_NEEDS_NAMESPACE_LEVEL_SUBSTITUTE is 580 // defined BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE needs 581 // to be expanded at namespace level before 582 // BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE can be used. 583 # define BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE( \ 584 args, substitute_macro, member_macro \ 585 ) \ 586 BOOST_MPL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE( \ 587 args, substitute_macro \ 588 ) \ 589 BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( \ 590 args \ 591 , BOOST_MPL_HAS_MEMBER_INTROSPECT_WITH_TEMPLATE_SFINAE \ 592 , substitute_macro \ 593 , member_macro \ 594 ) \ 595 /**/ 596 597 # endif // BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 598 599 // Note: In the current implementation the parameter and access macros 600 // are no longer expanded. 601 # if !BOOST_WORKAROUND(BOOST_MSVC, <= 1400) 602 # define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \ 603 BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE( \ 604 ( 4, ( trait, name, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, default_ ) ) \ 605 , BOOST_MPL_HAS_MEMBER_TEMPLATE_SUBSTITUTE_PARAMETER \ 606 , BOOST_MPL_HAS_MEMBER_TEMPLATE_ACCESS \ 607 ) \ 608 /**/ 609 # else 610 # define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \ 611 BOOST_MPL_HAS_MEMBER_WITH_TEMPLATE_SFINAE( \ 612 ( 4, ( trait, name, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, default_ ) ) \ 613 , BOOST_MPL_HAS_MEMBER_TEMPLATE_SUBSTITUTE_PARAMETER \ 614 , BOOST_MPL_HAS_MEMBER_TEMPLATE_ACCESS \ 615 ) \ 616 /**/ 617 # endif 618 619 #else // BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE 620 621 // placeholder implementation 622 623 # define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, default_) \ 624 template< typename T \ 625 , typename fallback_ = boost::mpl::bool_< default_ > > \ 626 struct trait { \ 627 BOOST_STATIC_CONSTANT(bool, value = fallback_::value); \ 628 typedef fallback_ type; \ 629 }; \ 630 /**/ 631 632 #endif // BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE 633 634 # define BOOST_MPL_HAS_XXX_TEMPLATE_DEF(name) \ 635 BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF( \ 636 BOOST_PP_CAT(has_, name), name, false \ 637 ) \ 638 /**/ 639 640 #endif // BOOST_MPL_HAS_XXX_HPP_INCLUDED 641