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
66namespace boost {
67
68template<typename F> struct result_of;
69template<typename F> struct tr1_result_of; // a TR1-style implementation of result_of
70
71#if !defined(BOOST_NO_SFINAE)
72namespace detail {
73
74BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
75
76// Work around a nvcc bug by only defining has_result when it's needed.
77#ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
78BOOST_MPL_HAS_XXX_TEMPLATE_DEF(result)
79#endif
80
81template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
82
83template<typename F> struct cpp0x_result_of;
84
85#ifdef BOOST_NO_SFINAE_EXPR
86
87// There doesn't seem to be any other way to turn this off such that the presence of
88// the user-defined operator,() below doesn't cause spurious warning all over the place,
89// so unconditionally turn it off.
90#if BOOST_MSVC
91# pragma warning(disable: 4913) // user defined binary operator ',' exists but no overload could convert all operands, default built-in binary operator ',' used
92#endif
93
94struct result_of_private_type {};
95
96struct result_of_weird_type {
97 friend result_of_private_type operator,(result_of_private_type, result_of_weird_type);
98};
99
100typedef char result_of_yes_type; // sizeof(result_of_yes_type) == 1
101typedef char (&result_of_no_type)[2]; // sizeof(result_of_no_type) == 2
102
103template<typename T>
104result_of_no_type result_of_is_private_type(T const &);
105result_of_yes_type result_of_is_private_type(result_of_private_type);
106
107template<typename C>
108struct result_of_callable_class : C {
109 result_of_callable_class();
110 typedef result_of_private_type const &(*pfn_t)(...);
111 operator pfn_t() const volatile;
112};
113
114template<typename C>
115struct result_of_wrap_callable_class {
116 typedef result_of_callable_class<C> type;
117};
118
119template<typename C>
120struct result_of_wrap_callable_class<C const> {
121 typedef result_of_callable_class<C> const type;
122};
123
124template<typename C>
125struct result_of_wrap_callable_class<C volatile> {
126 typedef result_of_callable_class<C> volatile type;
127};
128
129template<typename C>
130struct result_of_wrap_callable_class<C const volatile> {
131 typedef result_of_callable_class<C> const volatile type;
132};
133
134template<typename C>
135struct result_of_wrap_callable_class<C &> {
136 typedef typename result_of_wrap_callable_class<C>::type &type;
137};
138
139template<typename F, bool TestCallability = true> struct cpp0x_result_of_impl;
140
141#else // BOOST_NO_SFINAE_EXPR
142
143template<typename T>
144struct result_of_always_void
145{
146 typedef void type;
147};
148
149template<typename F, typename Enable = void> struct cpp0x_result_of_impl {};
150
151#endif // BOOST_NO_SFINAE_EXPR
152
153template<typename F>
154struct result_of_void_impl
155{
156 typedef void type;
157};
158
159template<typename R>
160struct result_of_void_impl<R (*)(void)>
161{
162 typedef R type;
163};
164
165template<typename R>
166struct result_of_void_impl<R (&)(void)>
167{
168 typedef R type;
169};
170
171// Determine the return type of a function pointer or pointer to member.
172template<typename F, typename FArgs>
173struct result_of_pointer
174 : tr1_result_of_impl<typename remove_cv<F>::type, FArgs, false> { };
175
176template<typename F, typename FArgs>
177struct tr1_result_of_impl<F, FArgs, true>
178{
179 typedef typename F::result_type type;
180};
181
182template<typename FArgs>
183struct is_function_with_no_args : mpl::false_ {};
184
185template<typename F>
186struct is_function_with_no_args<F(void)> : mpl::true_ {};
187
188template<typename F, typename FArgs>
189struct result_of_nested_result : F::template result<FArgs>
190{};
191
192template<typename F, typename FArgs>
193struct tr1_result_of_impl<F, FArgs, false>
194 : mpl::if_<is_function_with_no_args<FArgs>,
195 result_of_void_impl<F>,
196 result_of_nested_result<F, FArgs> >::type
197{};
198
199} // end namespace detail
200
201#define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_RESULT_OF_NUM_ARGS,<boost/utility/detail/result_of_iterate.hpp>))
202#include BOOST_PP_ITERATE()
203
204#else
205# define BOOST_NO_RESULT_OF 1
206#endif
207
208}
209
210#endif // BOOST_RESULT_OF_HPP
211

source code of boost/boost/utility/result_of.hpp