boost/utility/result_of.hpp

   1 // Boost result_of library
   2
   3 //  Copyright Douglas Gregor 2004. Use, modification and
   4 //  distribution is subject to the Boost Software License, Version
   5 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
   6 //  http://www.boost.org/LICENSE_1_0.txt)
   7
   8 // For more information, see http://www.boost.org/libs/utility
   9 #ifndef BOOST_RESULT_OF_HPP
  10 #define BOOST_RESULT_OF_HPP
  11
  12 #include <boost/config.hpp>
  13 #include <boost/preprocessor/cat.hpp>
  14 #include <boost/preprocessor/iteration/iterate.hpp>
  15 #include <boost/preprocessor/repetition/enum_params.hpp>
  16 #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
  17 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
  18 #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
  19 #include <boost/preprocessor/facilities/intercept.hpp>
  20 #include <boost/detail/workaround.hpp>
  21 #include <boost/mpl/has_xxx.hpp>
  22 #include <boost/mpl/if.hpp>
  23 #include <boost/mpl/eval_if.hpp>
  24 #include <boost/mpl/bool.hpp>
  25 #include <boost/mpl/identity.hpp>
  26 #include <boost/mpl/or.hpp>
  27 #include <boost/type_traits/is_class.hpp>
  28 #include <boost/type_traits/is_pointer.hpp>
  29 #include <boost/type_traits/is_member_function_pointer.hpp>
  30 #include <boost/type_traits/remove_cv.hpp>
  31 #include <boost/type_traits/remove_reference.hpp>
  32 #include <boost/utility/declval.hpp>
  33 #include <boost/utility/enable_if.hpp>
  34
  35 #ifndef BOOST_RESULT_OF_NUM_ARGS
  36 #  define BOOST_RESULT_OF_NUM_ARGS 16
  37 #endif
  38
  39 // Use the decltype-based version of result_of by default if the compiler
  40 // supports N3276 <http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2011/n3276.pdf>.
  41 // The user can force the choice by defining BOOST_RESULT_OF_USE_DECLTYPE,
  42 // BOOST_RESULT_OF_USE_TR1, or BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK but not more than one!
  43 #if (defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_RESULT_OF_USE_TR1)) || \
  44     (defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)) || \
  45     (defined(BOOST_RESULT_OF_USE_TR1) && defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK))
  46 #  error More than one of BOOST_RESULT_OF_USE_DECLTYPE, BOOST_RESULT_OF_USE_TR1 and \
  47   BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK cannot be defined at the same time.
  48 #endif
  49
  50 #if defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK) && defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
  51 #  error Cannot fallback to decltype if BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE is not defined.
  52 #endif
  53
  54 #ifndef BOOST_RESULT_OF_USE_TR1
  55 #  ifndef BOOST_RESULT_OF_USE_DECLTYPE
  56 #    ifndef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
  57 #      ifndef BOOST_NO_CXX11_DECLTYPE_N3276 // this implies !defined(BOOST_NO_CXX11_DECLTYPE)
  58 #        define BOOST_RESULT_OF_USE_DECLTYPE
  59 #      else
  60 #        define BOOST_RESULT_OF_USE_TR1
  61 #      endif
  62 #    endif
  63 #  endif
  64 #endif
  65
  66 namespace boost {
  67
  68 template<typename F> struct result_of;
  69 template<typename F> struct tr1_result_of; // a TR1-style implementation of result_of
  70
  71 #if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  72 namespace detail {
  73
  74 BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
  75
  76 BOOST_MPL_HAS_XXX_TEMPLATE_DEF(result)
  77
  78 template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
  79
  80 template<typename F> struct cpp0x_result_of;
  81
  82 #ifdef BOOST_NO_SFINAE_EXPR
  83
  84 // There doesn't seem to be any other way to turn this off such that the presence of
  85 // the user-defined operator,() below doesn't cause spurious warning all over the place,
  86 // so unconditionally turn it off.
  87 #if BOOST_MSVC
  88 #  pragma warning(disable: 4913) // user defined binary operator ',' exists but no overload could convert all operands, default built-in binary operator ',' used
  89 #endif
  90
  91 struct result_of_private_type {};
  92
  93 struct result_of_weird_type {
  94   friend result_of_private_type operator,(result_of_private_type, result_of_weird_type);
  95 };
  96
  97 typedef char result_of_yes_type;      // sizeof(result_of_yes_type) == 1
  98 typedef char (&result_of_no_type)[2]; // sizeof(result_of_no_type)  == 2
  99
 100 template<typename T>
 101 result_of_no_type result_of_is_private_type(T const &);
 102 result_of_yes_type result_of_is_private_type(result_of_private_type);
 103
 104 template<typename C>
 105 struct result_of_callable_class : C {
 106     result_of_callable_class();
 107     typedef result_of_private_type const &(*pfn_t)(...);
 108     operator pfn_t() const volatile;
 109 };
 110
 111 template<typename C>
 112 struct result_of_wrap_callable_class {
 113   typedef result_of_callable_class<C> type;
 114 };
 115
 116 template<typename C>
 117 struct result_of_wrap_callable_class<C const> {
 118   typedef result_of_callable_class<C> const type;
 119 };
 120
 121 template<typename C>
 122 struct result_of_wrap_callable_class<C volatile> {
 123   typedef result_of_callable_class<C> volatile type;
 124 };
 125
 126 template<typename C>
 127 struct result_of_wrap_callable_class<C const volatile> {
 128   typedef result_of_callable_class<C> const volatile type;
 129 };
 130
 131 template<typename C>
 132 struct result_of_wrap_callable_class<C &> {
 133   typedef typename result_of_wrap_callable_class<C>::type &type;
 134 };
 135
 136 template<typename F, bool TestCallability = true> struct cpp0x_result_of_impl;
 137
 138 #else // BOOST_NO_SFINAE_EXPR
 139
 140 template<typename T>
 141 struct result_of_always_void
 142 {
 143   typedef void type;
 144 };
 145
 146 template<typename F, typename Enable = void> struct cpp0x_result_of_impl {};
 147
 148 #endif // BOOST_NO_SFINAE_EXPR
 149
 150 template<typename F>
 151 struct result_of_void_impl
 152 {
 153   typedef void type;
 154 };
 155
 156 template<typename R>
 157 struct result_of_void_impl<R (*)(void)>
 158 {
 159   typedef R type;
 160 };
 161
 162 template<typename R>
 163 struct result_of_void_impl<R (&)(void)>
 164 {
 165   typedef R type;
 166 };
 167
 168 // Determine the return type of a function pointer or pointer to member.
 169 template<typename F, typename FArgs>
 170 struct result_of_pointer
 171   : tr1_result_of_impl<typename remove_cv<F>::type, FArgs, false> { };
 172
 173 template<typename F, typename FArgs>
 174 struct tr1_result_of_impl<F, FArgs, true>
 175 {
 176   typedef typename F::result_type type;
 177 };
 178
 179 template<typename FArgs>
 180 struct is_function_with_no_args : mpl::false_ {};
 181
 182 template<typename F>
 183 struct is_function_with_no_args<F(void)> : mpl::true_ {};
 184
 185 template<typename F, typename FArgs>
 186 struct result_of_nested_result : F::template result<FArgs>
 187 {};
 188
 189 template<typename F, typename FArgs>
 190 struct tr1_result_of_impl<F, FArgs, false>
 191   : mpl::if_<is_function_with_no_args<FArgs>,
 192              result_of_void_impl<F>,
 193              result_of_nested_result<F, FArgs> >::type
 194 {};
 195
 196 } // end namespace detail
 197
 198 #define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_RESULT_OF_NUM_ARGS,<boost/utility/detail/result_of_iterate.hpp>))
 199 #include BOOST_PP_ITERATE()
 200
 201 #else
 202 #  define BOOST_NO_RESULT_OF 1
 203 #endif
 204
 205 }
 206
 207 #endif // BOOST_RESULT_OF_HPP