stc/exp/ml_stc_linux_make_v1.0/include/boost/mpl/has_xxx.hpp

   1 \r
   2 #ifndef BOOST_MPL_HAS_XXX_HPP_INCLUDED\r
   3 #define BOOST_MPL_HAS_XXX_HPP_INCLUDED\r
   4 \r
   5 // Copyright Aleksey Gurtovoy 2002-2006\r
   6 // Copyright David Abrahams 2002-2003\r
   7 //\r
   8 // Distributed under the Boost Software License, Version 1.0. \r
   9 // (See accompanying file LICENSE_1_0.txt or copy at \r
  10 // http://www.boost.org/LICENSE_1_0.txt)\r
  11 //\r
  12 // See http://www.boost.org/libs/mpl for documentation.\r
  13 \r
  14 // $Id: has_xxx.hpp 49273 2008-10-11 06:54:06Z agurtovoy $\r
  15 // $Date: 2008-10-11 02:54:06 -0400 (Sat, 11 Oct 2008) $\r
  16 // $Revision: 49273 $\r
  17 \r
  18 #include <boost/mpl/bool.hpp>\r
  19 #include <boost/mpl/aux_/type_wrapper.hpp>\r
  20 #include <boost/mpl/aux_/yes_no.hpp>\r
  21 #include <boost/mpl/aux_/config/has_xxx.hpp>\r
  22 #include <boost/mpl/aux_/config/msvc_typename.hpp>\r
  23 #include <boost/mpl/aux_/config/msvc.hpp>\r
  24 #include <boost/mpl/aux_/config/static_constant.hpp>\r
  25 #include <boost/mpl/aux_/config/workaround.hpp>\r
  26 \r
  27 #include <boost/preprocessor/cat.hpp>\r
  28 \r
  29 #if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x590) )\r
  30 # include <boost/type_traits/is_class.hpp>\r
  31 #endif\r
  32 \r
  33 #if !defined(BOOST_MPL_CFG_NO_HAS_XXX)\r
  34 \r
  35 #   if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)\r
  36 \r
  37 // agurt, 11/sep/02: MSVC-specific version (< 7.1), based on a USENET \r
  38 // newsgroup's posting by John Madsen (comp.lang.c++.moderated, \r
  39 // 1999-11-12 19:17:06 GMT); the code is _not_ standard-conforming, but \r
  40 // it works way more reliably than the SFINAE-based implementation\r
  41 \r
  42 // Modified dwa 8/Oct/02 to handle reference types.\r
  43 \r
  44 #   include <boost/mpl/if.hpp>\r
  45 #   include <boost/mpl/bool.hpp>\r
  46 \r
  47 namespace boost { namespace mpl { namespace aux {\r
  48 \r
  49 struct has_xxx_tag;\r
  50 \r
  51 #if BOOST_WORKAROUND(BOOST_MSVC, == 1300)\r
  52 template< typename U > struct msvc_incomplete_array\r
  53 {\r
  54     typedef char (&type)[sizeof(U) + 1];\r
  55 };\r
  56 #endif\r
  57 \r
  58 template< typename T >\r
  59 struct msvc_is_incomplete\r
  60 {\r
  61     // MSVC is capable of some kinds of SFINAE.  If U is an incomplete\r
  62     // type, it won't pick the second overload\r
  63     static char tester(...);\r
  64 \r
  65 #if BOOST_WORKAROUND(BOOST_MSVC, == 1300)\r
  66     template< typename U >\r
  67     static typename msvc_incomplete_array<U>::type tester(type_wrapper<U>);\r
  68 #else\r
  69     template< typename U >\r
  70     static char (& tester(type_wrapper<U>) )[sizeof(U)+1];\r
  71 #endif \r
  72     \r
  73     BOOST_STATIC_CONSTANT(bool, value = \r
  74           sizeof(tester(type_wrapper<T>())) == 1\r
  75         );\r
  76 };\r
  77 \r
  78 template<>\r
  79 struct msvc_is_incomplete<int>\r
  80 {\r
  81     BOOST_STATIC_CONSTANT(bool, value = false);\r
  82 };\r
  83 \r
  84 }}}\r
  85 \r
  86 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, default_) \\r
  87 template< typename T, typename name = ::boost::mpl::aux::has_xxx_tag > \\r
  88 struct BOOST_PP_CAT(trait,_impl) : T \\r
  89 { \\r
  90     static boost::mpl::aux::no_tag \\r
  91     test(void(*)(::boost::mpl::aux::has_xxx_tag)); \\r
  92     \\r
  93     static boost::mpl::aux::yes_tag test(...); \\r
  94     \\r
  95     BOOST_STATIC_CONSTANT(bool, value = \\r
  96           sizeof(test(static_cast<void(*)(name)>(0))) \\r
  97             != sizeof(boost::mpl::aux::no_tag) \\r
  98         ); \\r
  99     typedef boost::mpl::bool_<value> type; \\r
 100 }; \\r
 101 \\r
 102 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \\r
 103 struct trait \\r
 104     : boost::mpl::if_c< \\r
 105           boost::mpl::aux::msvc_is_incomplete<T>::value \\r
 106         , boost::mpl::bool_<false> \\r
 107         , BOOST_PP_CAT(trait,_impl)<T> \\r
 108         >::type \\r
 109 { \\r
 110 }; \\r
 111 \\r
 112 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, void) \\r
 113 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, bool) \\r
 114 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, char) \\r
 115 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed char) \\r
 116 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned char) \\r
 117 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed short) \\r
 118 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned short) \\r
 119 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed int) \\r
 120 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned int) \\r
 121 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed long) \\r
 122 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned long) \\r
 123 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, float) \\r
 124 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, double) \\r
 125 BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, long double) \\r
 126 /**/\r
 127 \r
 128 #   define BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, T) \\r
 129 template<> struct trait<T> \\r
 130 { \\r
 131     BOOST_STATIC_CONSTANT(bool, value = false); \\r
 132     typedef boost::mpl::bool_<false> type; \\r
 133 }; \\r
 134 /**/\r
 135 \r
 136 #if !defined(BOOST_NO_INTRINSIC_WCHAR_T)\r
 137 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, unused) \\r
 138     BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, unused) \\r
 139     BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, wchar_t) \\r
 140 /**/\r
 141 #else\r
 142 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, unused) \\r
 143     BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, unused) \\r
 144 /**/\r
 145 #endif\r
 146 \r
 147 \r
 148 // SFINAE-based implementations below are derived from a USENET newsgroup's \r
 149 // posting by Rani Sharoni (comp.lang.c++.moderated, 2002-03-17 07:45:09 PST)\r
 150 \r
 151 #   elif BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \\r
 152       || BOOST_WORKAROUND(__IBMCPP__, <= 700)\r
 153 \r
 154 // MSVC 7.1+ & VACPP\r
 155 \r
 156 // agurt, 15/jun/05: replace overload-based SFINAE implementation with SFINAE\r
 157 // applied to partial specialization to fix some apparently random failures \r
 158 // (thanks to Daniel Wallin for researching this!)\r
 159 \r
 160 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \\r
 161 template< typename T > \\r
 162 struct BOOST_PP_CAT(trait, _msvc_sfinae_helper) \\r
 163 { \\r
 164     typedef void type; \\r
 165 };\\r
 166 \\r
 167 template< typename T, typename U = void > \\r
 168 struct BOOST_PP_CAT(trait,_impl_) \\r
 169 { \\r
 170     BOOST_STATIC_CONSTANT(bool, value = false); \\r
 171     typedef boost::mpl::bool_<value> type; \\r
 172 }; \\r
 173 \\r
 174 template< typename T > \\r
 175 struct BOOST_PP_CAT(trait,_impl_)< \\r
 176       T \\r
 177     , typename BOOST_PP_CAT(trait, _msvc_sfinae_helper)< typename T::name >::type \\r
 178     > \\r
 179 { \\r
 180     BOOST_STATIC_CONSTANT(bool, value = true); \\r
 181     typedef boost::mpl::bool_<value> type; \\r
 182 }; \\r
 183 \\r
 184 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \\r
 185 struct trait \\r
 186     : BOOST_PP_CAT(trait,_impl_)<T> \\r
 187 { \\r
 188 }; \\r
 189 /**/\r
 190 \r
 191 #   elif BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x590) )\r
 192 \r
 193 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_BCB_DEF(trait, trait_tester, name, default_) \\r
 194 template< typename T, bool IS_CLASS > \\r
 195 struct trait_tester \\r
 196 { \\r
 197     BOOST_STATIC_CONSTANT( bool,  value = false ); \\r
 198 }; \\r
 199 template< typename T > \\r
 200 struct trait_tester< T, true > \\r
 201 { \\r
 202     struct trait_tester_impl \\r
 203     { \\r
 204         template < class U > \\r
 205         static int  resolve( boost::mpl::aux::type_wrapper<U> const volatile * \\r
 206                            , boost::mpl::aux::type_wrapper<typename U::name >* = 0 ); \\r
 207         static char resolve( ... ); \\r
 208     }; \\r
 209     typedef boost::mpl::aux::type_wrapper<T> t_; \\r
 210     BOOST_STATIC_CONSTANT( bool, value = ( sizeof( trait_tester_impl::resolve( static_cast< t_ * >(0) ) ) == sizeof(int) ) ); \\r
 211 }; \\r
 212 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \\r
 213 struct trait           \\r
 214 {                      \\r
 215     BOOST_STATIC_CONSTANT( bool, value = (trait_tester< T, boost::is_class< T >::value >::value) );     \\r
 216     typedef boost::mpl::bool_< trait< T, fallback_ >::value > type; \\r
 217 };\r
 218 \r
 219 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \\r
 220     BOOST_MPL_HAS_XXX_TRAIT_NAMED_BCB_DEF( trait \\r
 221                                          , BOOST_PP_CAT(trait,_tester)      \\r
 222                                          , name       \\r
 223                                          , default_ ) \\r
 224 /**/\r
 225 \r
 226 #   else // other SFINAE-capable compilers\r
 227 \r
 228 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \\r
 229 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \\r
 230 struct trait \\r
 231 { \\r
 232     struct gcc_3_2_wknd \\r
 233     { \\r
 234         template< typename U > \\r
 235         static boost::mpl::aux::yes_tag test( \\r
 236               boost::mpl::aux::type_wrapper<U> const volatile* \\r
 237             , boost::mpl::aux::type_wrapper<BOOST_MSVC_TYPENAME U::name>* = 0 \\r
 238             ); \\r
 239     \\r
 240         static boost::mpl::aux::no_tag test(...); \\r
 241     }; \\r
 242     \\r
 243     typedef boost::mpl::aux::type_wrapper<T> t_; \\r
 244     BOOST_STATIC_CONSTANT(bool, value = \\r
 245           sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) \\r
 246             == sizeof(boost::mpl::aux::yes_tag) \\r
 247         ); \\r
 248     typedef boost::mpl::bool_<value> type; \\r
 249 }; \\r
 250 /**/\r
 251 \r
 252 #   endif // BOOST_WORKAROUND(BOOST_MSVC, <= 1300)\r
 253 \r
 254 \r
 255 #else // BOOST_MPL_CFG_NO_HAS_XXX\r
 256 \r
 257 // placeholder implementation\r
 258 \r
 259 #   define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \\r
 260 template< typename T, typename fallback_ = boost::mpl::bool_<default_> > \\r
 261 struct trait \\r
 262 { \\r
 263     BOOST_STATIC_CONSTANT(bool, value = fallback_::value); \\r
 264     typedef fallback_ type; \\r
 265 }; \\r
 266 /**/\r
 267 \r
 268 #endif\r
 269 \r
 270 #define BOOST_MPL_HAS_XXX_TRAIT_DEF(name) \\r
 271     BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(BOOST_PP_CAT(has_,name), name, false) \\r
 272 /**/\r
 273 \r
 274 #endif // BOOST_MPL_HAS_XXX_HPP_INCLUDED\r