boost/detail/indirect_traits.hpp

   1 // Copyright David Abrahams 2002.
   2 // Distributed under the Boost Software License, Version 1.0. (See
   3 // accompanying file LICENSE_1_0.txt or copy at
   4 // http://www.boost.org/LICENSE_1_0.txt)
   5 #ifndef INDIRECT_TRAITS_DWA2002131_HPP
   6 # define INDIRECT_TRAITS_DWA2002131_HPP
   7 # include <boost/type_traits/is_function.hpp>
   8 # include <boost/type_traits/is_reference.hpp>
   9 # include <boost/type_traits/is_pointer.hpp>
  10 # include <boost/type_traits/is_class.hpp>
  11 # include <boost/type_traits/is_const.hpp>
  12 # include <boost/type_traits/is_volatile.hpp>
  13 # include <boost/type_traits/is_member_function_pointer.hpp>
  14 # include <boost/type_traits/is_member_pointer.hpp>
  15 # include <boost/type_traits/remove_cv.hpp>
  16 # include <boost/type_traits/remove_reference.hpp>
  17 # include <boost/type_traits/remove_pointer.hpp>
  18
  19 # include <boost/type_traits/detail/ice_and.hpp>
  20 # include <boost/detail/workaround.hpp>
  21
  22 # include <boost/mpl/eval_if.hpp>
  23 # include <boost/mpl/if.hpp>
  24 # include <boost/mpl/bool.hpp>
  25 # include <boost/mpl/and.hpp>
  26 # include <boost/mpl/not.hpp>
  27 # include <boost/mpl/aux_/lambda_support.hpp>
  28
  29 #  ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  30 #   include <boost/detail/is_function_ref_tester.hpp>
  31 #  endif
  32
  33 namespace boost { namespace detail {
  34
  35 namespace indirect_traits {
  36
  37 #  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  38 template <class T>
  39 struct is_reference_to_const : mpl::false_
  40 {
  41 };
  42
  43 template <class T>
  44 struct is_reference_to_const<T const&> : mpl::true_
  45 {
  46 };
  47
  48 #   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
  49 template<class T>
  50 struct is_reference_to_const<T const volatile&> : mpl::true_
  51 {
  52 };
  53 #   endif
  54
  55 template <class T>
  56 struct is_reference_to_function : mpl::false_
  57 {
  58 };
  59
  60 template <class T>
  61 struct is_reference_to_function<T&> : is_function<T>
  62 {
  63 };
  64
  65 template <class T>
  66 struct is_pointer_to_function : mpl::false_
  67 {
  68 };
  69
  70 // There's no such thing as a pointer-to-cv-function, so we don't need
  71 // specializations for those
  72 template <class T>
  73 struct is_pointer_to_function<T*> : is_function<T>
  74 {
  75 };
  76
  77 template <class T>
  78 struct is_reference_to_member_function_pointer_impl : mpl::false_
  79 {
  80 };
  81
  82 template <class T>
  83 struct is_reference_to_member_function_pointer_impl<T&>
  84     : is_member_function_pointer<typename remove_cv<T>::type>
  85 {
  86 };
  87
  88
  89 template <class T>
  90 struct is_reference_to_member_function_pointer
  91     : is_reference_to_member_function_pointer_impl<T>
  92 {
  93     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
  94 };
  95
  96 template <class T>
  97 struct is_reference_to_function_pointer_aux
  98     : mpl::and_<
  99           is_reference<T>
 100         , is_pointer_to_function<
 101               typename remove_cv<
 102                   typename remove_reference<T>::type
 103               >::type
 104           >
 105       >
 106 {
 107     // There's no such thing as a pointer-to-cv-function, so we don't need specializations for those
 108 };
 109
 110 template <class T>
 111 struct is_reference_to_function_pointer
 112     : mpl::if_<
 113           is_reference_to_function<T>
 114         , mpl::false_
 115         , is_reference_to_function_pointer_aux<T>
 116      >::type
 117 {
 118 };
 119
 120 template <class T>
 121 struct is_reference_to_non_const
 122     : mpl::and_<
 123           is_reference<T>
 124         , mpl::not_<
 125              is_reference_to_const<T>
 126           >
 127       >
 128 {
 129 };
 130
 131 template <class T>
 132 struct is_reference_to_volatile : mpl::false_
 133 {
 134 };
 135
 136 template <class T>
 137 struct is_reference_to_volatile<T volatile&> : mpl::true_
 138 {
 139 };
 140
 141 #   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
 142 template <class T>
 143 struct is_reference_to_volatile<T const volatile&> : mpl::true_
 144 {
 145 };
 146 #   endif
 147
 148
 149 template <class T>
 150 struct is_reference_to_pointer : mpl::false_
 151 {
 152 };
 153
 154 template <class T>
 155 struct is_reference_to_pointer<T*&> : mpl::true_
 156 {
 157 };
 158
 159 template <class T>
 160 struct is_reference_to_pointer<T* const&> : mpl::true_
 161 {
 162 };
 163
 164 template <class T>
 165 struct is_reference_to_pointer<T* volatile&> : mpl::true_
 166 {
 167 };
 168
 169 template <class T>
 170 struct is_reference_to_pointer<T* const volatile&> : mpl::true_
 171 {
 172 };
 173
 174 template <class T>
 175 struct is_reference_to_class
 176     : mpl::and_<
 177           is_reference<T>
 178         , is_class<
 179               typename remove_cv<
 180                   typename remove_reference<T>::type
 181               >::type
 182           >
 183       >
 184 {
 185     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
 186 };
 187
 188 template <class T>
 189 struct is_pointer_to_class
 190     : mpl::and_<
 191           is_pointer<T>
 192         , is_class<
 193               typename remove_cv<
 194                   typename remove_pointer<T>::type
 195               >::type
 196           >
 197       >
 198 {
 199     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T))
 200 };
 201
 202 #  else
 203
 204 using namespace boost::detail::is_function_ref_tester_;
 205
 206 typedef char (&inner_yes_type)[3];
 207 typedef char (&inner_no_type)[2];
 208 typedef char (&outer_no_type)[1];
 209
 210 template <typename V>
 211 struct is_const_help
 212 {
 213     typedef typename mpl::if_<
 214           is_const<V>
 215         , inner_yes_type
 216         , inner_no_type
 217         >::type type;
 218 };
 219
 220 template <typename V>
 221 struct is_volatile_help
 222 {
 223     typedef typename mpl::if_<
 224           is_volatile<V>
 225         , inner_yes_type
 226         , inner_no_type
 227         >::type type;
 228 };
 229
 230 template <typename V>
 231 struct is_pointer_help
 232 {
 233     typedef typename mpl::if_<
 234           is_pointer<V>
 235         , inner_yes_type
 236         , inner_no_type
 237         >::type type;
 238 };
 239
 240 template <typename V>
 241 struct is_class_help
 242 {
 243     typedef typename mpl::if_<
 244           is_class<V>
 245         , inner_yes_type
 246         , inner_no_type
 247         >::type type;
 248 };
 249
 250 template <class T>
 251 struct is_reference_to_function_aux
 252 {
 253     static T t;
 254     BOOST_STATIC_CONSTANT(
 255         bool, value = sizeof(detail::is_function_ref_tester(t,0)) == sizeof(::boost::type_traits::yes_type));
 256     typedef mpl::bool_<value> type;
 257  };
 258
 259 template <class T>
 260 struct is_reference_to_function
 261     : mpl::if_<is_reference<T>, is_reference_to_function_aux<T>, mpl::bool_<false> >::type
 262 {
 263 };
 264
 265 template <class T>
 266 struct is_pointer_to_function_aux
 267 {
 268     static T t;
 269     BOOST_STATIC_CONSTANT(
 270         bool, value
 271         = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type));
 272     typedef mpl::bool_<value> type;
 273 };
 274
 275 template <class T>
 276 struct is_pointer_to_function
 277     : mpl::if_<is_pointer<T>, is_pointer_to_function_aux<T>, mpl::bool_<false> >::type
 278 {
 279     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_function,(T))
 280 };
 281
 282 struct false_helper1
 283 {
 284     template <class T>
 285     struct apply : mpl::false_
 286     {
 287     };
 288 };
 289
 290 template <typename V>
 291 typename is_const_help<V>::type reference_to_const_helper(V&);
 292 outer_no_type
 293 reference_to_const_helper(...);
 294
 295 struct true_helper1
 296 {
 297     template <class T>
 298     struct apply
 299     {
 300         static T t;
 301         BOOST_STATIC_CONSTANT(
 302             bool, value
 303             = sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type));
 304         typedef mpl::bool_<value> type;
 305     };
 306 };
 307
 308 template <bool ref = true>
 309 struct is_reference_to_const_helper1 : true_helper1
 310 {
 311 };
 312
 313 template <>
 314 struct is_reference_to_const_helper1<false> : false_helper1
 315 {
 316 };
 317
 318
 319 template <class T>
 320 struct is_reference_to_const
 321     : is_reference_to_const_helper1<is_reference<T>::value>::template apply<T>
 322 {
 323 };
 324
 325
 326 template <bool ref = true>
 327 struct is_reference_to_non_const_helper1
 328 {
 329     template <class T>
 330     struct apply
 331     {
 332         static T t;
 333         BOOST_STATIC_CONSTANT(
 334             bool, value
 335             = sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type));
 336
 337         typedef mpl::bool_<value> type;
 338     };
 339 };
 340
 341 template <>
 342 struct is_reference_to_non_const_helper1<false> : false_helper1
 343 {
 344 };
 345
 346
 347 template <class T>
 348 struct is_reference_to_non_const
 349     : is_reference_to_non_const_helper1<is_reference<T>::value>::template apply<T>
 350 {
 351     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_non_const,(T))
 352 };
 353
 354
 355 template <typename V>
 356 typename is_volatile_help<V>::type reference_to_volatile_helper(V&);
 357 outer_no_type
 358 reference_to_volatile_helper(...);
 359
 360 template <bool ref = true>
 361 struct is_reference_to_volatile_helper1
 362 {
 363     template <class T>
 364     struct apply
 365     {
 366         static T t;
 367         BOOST_STATIC_CONSTANT(
 368             bool, value
 369             = sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type));
 370         typedef mpl::bool_<value> type;
 371     };
 372 };
 373
 374 template <>
 375 struct is_reference_to_volatile_helper1<false> : false_helper1
 376 {
 377 };
 378
 379
 380 template <class T>
 381 struct is_reference_to_volatile
 382     : is_reference_to_volatile_helper1<is_reference<T>::value>::template apply<T>
 383 {
 384 };
 385
 386 template <typename V>
 387 typename is_pointer_help<V>::type reference_to_pointer_helper(V&);
 388 outer_no_type reference_to_pointer_helper(...);
 389
 390 template <class T>
 391 struct reference_to_pointer_impl
 392 {
 393     static T t;
 394     BOOST_STATIC_CONSTANT(
 395         bool, value
 396         = (sizeof((reference_to_pointer_helper)(t)) == sizeof(inner_yes_type))
 397         );
 398
 399     typedef mpl::bool_<value> type;
 400 };
 401
 402 template <class T>
 403 struct is_reference_to_pointer
 404   : mpl::eval_if<is_reference<T>, reference_to_pointer_impl<T>, mpl::false_>::type
 405 {
 406     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_pointer,(T))
 407 };
 408
 409 template <class T>
 410 struct is_reference_to_function_pointer
 411   : mpl::eval_if<is_reference<T>, is_pointer_to_function_aux<T>, mpl::false_>::type
 412 {
 413     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_function_pointer,(T))
 414 };
 415
 416
 417 template <class T>
 418 struct is_member_function_pointer_help
 419     : mpl::if_<is_member_function_pointer<T>, inner_yes_type, inner_no_type>
 420 {};
 421
 422 template <typename V>
 423 typename is_member_function_pointer_help<V>::type member_function_pointer_helper(V&);
 424 outer_no_type member_function_pointer_helper(...);
 425
 426 template <class T>
 427 struct is_pointer_to_member_function_aux
 428 {
 429     static T t;
 430     BOOST_STATIC_CONSTANT(
 431         bool, value
 432         = sizeof((member_function_pointer_helper)(t)) == sizeof(inner_yes_type));
 433     typedef mpl::bool_<value> type;
 434 };
 435
 436 template <class T>
 437 struct is_reference_to_member_function_pointer
 438     : mpl::if_<
 439         is_reference<T>
 440         , is_pointer_to_member_function_aux<T>
 441         , mpl::bool_<false>
 442      >::type
 443 {
 444     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
 445 };
 446
 447 template <typename V>
 448 typename is_class_help<V>::type reference_to_class_helper(V const volatile&);
 449 outer_no_type reference_to_class_helper(...);
 450
 451 template <class T>
 452 struct is_reference_to_class
 453 {
 454     static T t;
 455     BOOST_STATIC_CONSTANT(
 456         bool, value
 457         = (is_reference<T>::value
 458            & (sizeof(reference_to_class_helper(t)) == sizeof(inner_yes_type)))
 459         );
 460     typedef mpl::bool_<value> type;
 461     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
 462 };
 463
 464 template <typename V>
 465 typename is_class_help<V>::type pointer_to_class_helper(V const volatile*);
 466 outer_no_type pointer_to_class_helper(...);
 467
 468 template <class T>
 469 struct is_pointer_to_class
 470 {
 471     static T t;
 472     BOOST_STATIC_CONSTANT(
 473         bool, value
 474         = (is_pointer<T>::value
 475            && sizeof(pointer_to_class_helper(t)) == sizeof(inner_yes_type))
 476         );
 477     typedef mpl::bool_<value> type;
 478 };
 479 #  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 480
 481 }
 482
 483 using namespace indirect_traits;
 484
 485 }} // namespace boost::python::detail
 486
 487 #endif // INDIRECT_TRAITS_DWA2002131_HPP