[ceph.git] / ceph / src / boost / libs / proto / include / boost / proto / detail / decltype.hpp

///////////////////////////////////////////////////////////////////////////////
/// \file decltype.hpp
/// Contains definition the BOOST_PROTO_DECLTYPE_() macro and assorted helpers
//
//  Copyright 2008 Eric Niebler. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008
#define BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008

#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/get_pointer.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/iteration/local.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/type_traits/is_class.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_function.hpp>
#include <boost/type_traits/is_member_object_pointer.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/typeof/typeof.hpp>
#include <boost/utility/addressof.hpp>
#include <boost/utility/result_of.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/detail/any.hpp>

#if defined(_MSC_VER)
# pragma warning(push)
# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
#endif

// We're STILL using Boost.Typeof on MSVC even for msvc-11.0 because of this bug:
// https://connect.microsoft.com/VisualStudio/feedback/details/765392/decltype-of-a-pointer-to-member-operator-gets-ref-qualification-wrong
#if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1700))
# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) typedef decltype((EXPR)) TYPE;
#else
# define BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(NESTED, EXPR)                                     \
    BOOST_TYPEOF_NESTED_TYPEDEF_TPL(BOOST_PP_CAT(nested_and_hidden_, NESTED), EXPR)                 \
    static int const BOOST_PP_CAT(sz, NESTED) = sizeof(boost::proto::detail::check_reference(EXPR));\
    struct NESTED                                                                                   \
      : boost::mpl::if_c<                                                                           \
            1 == BOOST_PP_CAT(sz, NESTED)                                                           \
          , typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type &                               \
          , typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type                                 \
        >                                                                                           \
    {};
# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE)                                                          \
    BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(BOOST_PP_CAT(nested_, TYPE), (EXPR))                   \
    typedef typename BOOST_PP_CAT(nested_, TYPE)::type TYPE;
#endif

namespace boost { namespace proto
{
    namespace detail
    {
        ////////////////////////////////////////////////////////////////////////////////////////////
        template<typename T>
        struct as_mutable
        {
            typedef T &type;
        };

        template<typename T>
        struct as_mutable<T &>
        {
            typedef T &type;
        };

        template<typename T>
        struct as_mutable<T const &>
        {
            typedef T &type;
        };

        ////////////////////////////////////////////////////////////////////////////////////////////
        template<typename T>
        T make();

        ////////////////////////////////////////////////////////////////////////////////////////////
        template<typename T>
        typename as_mutable<T>::type make_mutable();

        ////////////////////////////////////////////////////////////////////////////////////////////
        template<typename T>
        struct subscript_wrapper
          : T
        {
            using T::operator[];

            #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
            any operator[](any const volatile &) const volatile;
            #else
            any operator[](any const &) const volatile;
            #endif
        };

        ////////////////////////////////////////////////////////////////////////////////////////////
        template<typename T>
        struct as_subscriptable
        {
            typedef
                typename mpl::if_c<
                    is_class<T>::value
                  , subscript_wrapper<T>
                  , T
                >::type
            type;
        };

        template<typename T>
        struct as_subscriptable<T const>
        {
            typedef
                typename mpl::if_c<
                    is_class<T>::value
                  , subscript_wrapper<T> const
                  , T const
                >::type
            type;
        };

        template<typename T>
        struct as_subscriptable<T &>
        {
            typedef
                typename mpl::if_c<
                    is_class<T>::value
                  , subscript_wrapper<T> &
                  , T &
                >::type
            type;
        };

        template<typename T>
        struct as_subscriptable<T const &>
        {
            typedef
                typename mpl::if_c<
                    is_class<T>::value
                  , subscript_wrapper<T> const &
                  , T const &
                >::type
            type;
        };

        ////////////////////////////////////////////////////////////////////////////////////////////
        template<typename T>
        typename as_subscriptable<T>::type make_subscriptable();

        ////////////////////////////////////////////////////////////////////////////////////////////
        template<typename T>
        char check_reference(T &);

        template<typename T>
        char (&check_reference(T const &))[2];

        namespace has_get_pointerns
        {
            using boost::get_pointer;
            void *(&get_pointer(...))[2];

            ////////////////////////////////////////////////////////////////////////////////////////////
            template<typename T>
            struct has_get_pointer
            {
                static const bool value = sizeof(void *) == sizeof(get_pointer(make<T &>()));
                typedef mpl::bool_<value> type;
            };
        }

        using has_get_pointerns::has_get_pointer;

        ////////////////////////////////////////////////////////////////////////////////////////////
        template<typename T>
        struct class_member_traits;

        template<typename T, typename U>
        struct class_member_traits<T U::*>
        {
            typedef U class_type;
            typedef T result_type;
        };

        // Other specializations are generated by the preprocessor
        #include <boost/proto/detail/class_member_traits.hpp>

        ////////////////////////////////////////////////////////////////////////////////////////////
        template<typename T>
        T &lvalue(T &t)
        {
            return t;
        }

        template<typename T>
        T const &lvalue(T const &t)
        {
            return t;
        }

        ////////////////////////////////////////////////////////////////////////////////////////////
        template<typename U, typename V, typename T>
        U *proto_get_pointer(T &t, V *, U *)
        {
            return boost::addressof(t);
        }

        template<typename U, typename V, typename T>
        U const *proto_get_pointer(T &t, V *, U const *)
        {
            return boost::addressof(t);
        }

        template<typename U, typename V, typename T>
        V *proto_get_pointer(T &t, V *, ...)
        {
            return get_pointer(t);
        }

        ////////////////////////////////////////////////////////////////////////////////////////////
        #define BOOST_PROTO_USE_GET_POINTER()                                                       \
        using namespace boost::proto::detail::get_pointerns                                         \
        /**/

        #define BOOST_PROTO_GET_POINTER(Type, Obj)                                                  \
        boost::proto::detail::proto_get_pointer<Type>(                                              \
            boost::proto::detail::lvalue(Obj)                                                       \
          , (true ? 0 : get_pointer(Obj))                                                           \
          , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(Obj)))                        \
        )                                                                                           \
        /**/

        ////////////////////////////////////////////////////////////////////////////////////////////
        namespace get_pointerns
        {
            using boost::get_pointer;

            template<typename T>
            typename disable_if_c<has_get_pointer<T>::value, T *>::type
            get_pointer(T &t)
            {
                return boost::addressof(t);
            }

            template<typename T>
            typename disable_if_c<has_get_pointer<T>::value, T const *>::type
            get_pointer(T const &t)
            {
                return boost::addressof(t);
            }

            char test_ptr_to_const(void *);
            char (&test_ptr_to_const(void const *))[2];

            template<typename U> char test_V_is_a_U(U *);
            template<typename U> char test_V_is_a_U(U const *);
            template<typename U> char (&test_V_is_a_U(...))[2];

            ////////////////////////////////////////////////////////////////////////////////////////////
            // result_of_ is a wrapper around boost::result_of that also handles "invocations" of
            // member object pointers.
            template<typename T, typename Void = void>
            struct result_of_
              : BOOST_PROTO_RESULT_OF<T>
            {};

            template<typename T, typename U, typename V>
            struct result_of_<T U::*(V), typename enable_if_c<is_member_object_pointer<T U::*>::value>::type>
            {
                static const bool is_V_a_smart_ptr = 2 == sizeof(test_V_is_a_U<U>(&lvalue(make<V>())));
                static const bool is_ptr_to_const = 2 == sizeof(test_ptr_to_const(BOOST_PROTO_GET_POINTER(U, make<V>())));

                // If V is not a U, then it is a (smart) pointer and we can always return an lvalue.
                // Otherwise, we can only return an lvalue if we are given one.
                typedef
                    typename mpl::eval_if_c<
                        (is_V_a_smart_ptr || is_reference<V>::value)
                      , mpl::eval_if_c<
                            is_ptr_to_const
                          , add_reference<typename add_const<T>::type>
                          , add_reference<T>
                        >
                      , mpl::identity<T>
                    >::type
                type;
            };

            ////////////////////////////////////////////////////////////////////////////////////////////
            template<
                typename T
              , typename U
              , bool IsMemPtr = is_member_object_pointer<
                    typename remove_reference<U>::type
                >::value
            >
            struct mem_ptr_fun
            {
                BOOST_PROTO_DECLTYPE_(
                    proto::detail::make_mutable<T>() ->* proto::detail::make<U>()
                  , result_type
                )

                result_type operator()(
                    typename add_reference<typename add_const<T>::type>::type t
                  , typename add_reference<typename add_const<U>::type>::type u
                ) const
                {
                    return t ->* u;
                }
            };

            ////////////////////////////////////////////////////////////////////////////////////////////
            template<typename T, typename U>
            struct mem_ptr_fun<T, U, true>
            {
                typedef
                    typename class_member_traits<
                        typename uncvref<U>::type
                    >::class_type
                V;

                BOOST_PROTO_DECLTYPE_(
                    BOOST_PROTO_GET_POINTER(V, proto::detail::make_mutable<T>()) ->* proto::detail::make<U>()
                  , result_type
                )

                result_type operator()(
                    typename add_reference<typename add_const<T>::type>::type t
                  , U u
                ) const
                {
                    return BOOST_PROTO_GET_POINTER(V, t) ->* u;
                }
            };
        }

        using get_pointerns::result_of_;
        using get_pointerns::mem_ptr_fun;

        ////////////////////////////////////////////////////////////////////////////////////////////
        template<typename A0, typename A1>
        struct comma_result
        {
            BOOST_PROTO_DECLTYPE_((proto::detail::make<A0>(), proto::detail::make<A1>()), type)
        };

        template<typename A0>
        struct comma_result<A0, void>
        {
            typedef void type;
        };

        template<typename A1>
        struct comma_result<void, A1>
        {
            typedef A1 type;
        };

        template<>
        struct comma_result<void, void>
        {
            typedef void type;
        };

        ////////////////////////////////////////////////////////////////////////////////////////////
        // normalize a function type for use with boost::result_of
        template<typename T, typename U = T>
        struct result_of_fixup
          : mpl::if_c<is_function<T>::value, T *, U>
        {};

        template<typename T, typename U>
        struct result_of_fixup<T &, U>
          : result_of_fixup<T, T>
        {};

        template<typename T, typename U>
        struct result_of_fixup<T const &, U>
          : result_of_fixup<T, T>
        {};

        template<typename T, typename U>
        struct result_of_fixup<T *, U>
          : result_of_fixup<T, U>
        {};

        template<typename R, typename T, typename U>
        struct result_of_fixup<R T::*, U>
        {
            typedef R T::*type;
        };

        template<typename T, typename U>
        struct result_of_fixup<T const, U>
          : result_of_fixup<T, U>
        {};

        //// Tests for result_of_fixup
        //struct bar {};
        //BOOST_MPL_ASSERT((is_same<bar,        result_of_fixup<bar>::type>));
        //BOOST_MPL_ASSERT((is_same<bar const,  result_of_fixup<bar const>::type>));
        //BOOST_MPL_ASSERT((is_same<bar,        result_of_fixup<bar &>::type>));
        //BOOST_MPL_ASSERT((is_same<bar const,  result_of_fixup<bar const &>::type>));
        //BOOST_MPL_ASSERT((is_same<void(*)(),  result_of_fixup<void(*)()>::type>));
        //BOOST_MPL_ASSERT((is_same<void(*)(),  result_of_fixup<void(* const)()>::type>));
        //BOOST_MPL_ASSERT((is_same<void(*)(),  result_of_fixup<void(* const &)()>::type>));
        //BOOST_MPL_ASSERT((is_same<void(*)(),  result_of_fixup<void(&)()>::type>));

        template<typename T, typename PMF>
        struct memfun
        {
            typedef typename uncvref<PMF>::type pmf_type;
            typedef typename class_member_traits<pmf_type>::class_type V;
            typedef typename class_member_traits<pmf_type>::result_type result_type;

            memfun(T t, pmf_type p)
              : obj(t)
              , pmf(p)
            {}

            result_type operator()() const
            {
                BOOST_PROTO_USE_GET_POINTER();
                return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)();
            }

            // Other overloads generated by the preprocessor
            #include <boost/proto/detail/memfun_funop.hpp>

        private:
            T obj;
            pmf_type pmf;
        };

    } // namespace detail
}}

#if defined(_MSC_VER)
# pragma warning(pop)
#endif

#endif
Commit	Line	Data
7c673cae FG	1	///////////////////////////////////////////////////////////////////////////////
	2	/// \file decltype.hpp
	3	/// Contains definition the BOOST_PROTO_DECLTYPE_() macro and assorted helpers
	4	//
	5	// Copyright 2008 Eric Niebler. Distributed under the Boost
	6	// Software License, Version 1.0. (See accompanying file
	7	// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
	8
	9	#ifndef BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008
	10	#define BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008
	11
	12	#include <boost/config.hpp>
	13	#include <boost/detail/workaround.hpp>
	14	#include <boost/get_pointer.hpp>
	15	#include <boost/preprocessor/cat.hpp>
	16	#include <boost/preprocessor/repetition/enum_params.hpp>
	17	#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
	18	#include <boost/preprocessor/repetition/enum_binary_params.hpp>
	19	#include <boost/preprocessor/repetition/repeat.hpp>
	20	#include <boost/preprocessor/repetition/repeat_from_to.hpp>
	21	#include <boost/preprocessor/iteration/local.hpp>
	22	#include <boost/mpl/if.hpp>
	23	#include <boost/mpl/eval_if.hpp>
	24	#include <boost/mpl/identity.hpp>
	25	#include <boost/type_traits/is_class.hpp>
	26	#include <boost/type_traits/remove_reference.hpp>
	27	#include <boost/type_traits/is_pointer.hpp>
	28	#include <boost/type_traits/is_function.hpp>
	29	#include <boost/type_traits/is_member_object_pointer.hpp>
	30	#include <boost/type_traits/add_const.hpp>
	31	#include <boost/type_traits/add_reference.hpp>
	32	#include <boost/typeof/typeof.hpp>
	33	#include <boost/utility/addressof.hpp>
	34	#include <boost/utility/result_of.hpp>
	35	#include <boost/utility/enable_if.hpp>
	36	#include <boost/proto/proto_fwd.hpp>
	37	#include <boost/proto/detail/any.hpp>
	38
	39	#if defined(_MSC_VER)
	40	# pragma warning(push)
	41	# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
	42	#endif
	43
	44	// We're STILL using Boost.Typeof on MSVC even for msvc-11.0 because of this bug:
	45	// https://connect.microsoft.com/VisualStudio/feedback/details/765392/decltype-of-a-pointer-to-member-operator-gets-ref-qualification-wrong
	46	#if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1700))
	47	# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) typedef decltype((EXPR)) TYPE;
	48	#else
	49	# define BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(NESTED, EXPR) \
	50	BOOST_TYPEOF_NESTED_TYPEDEF_TPL(BOOST_PP_CAT(nested_and_hidden_, NESTED), EXPR) \
	51	static int const BOOST_PP_CAT(sz, NESTED) = sizeof(boost::proto::detail::check_reference(EXPR));\
	52	struct NESTED \
	53	: boost::mpl::if_c< \
	54	1 == BOOST_PP_CAT(sz, NESTED) \
	55	, typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type & \
	56	, typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type \
	57	> \
	58	{};
	59	# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) \
	60	BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(BOOST_PP_CAT(nested_, TYPE), (EXPR)) \
	61	typedef typename BOOST_PP_CAT(nested_, TYPE)::type TYPE;
	62	#endif
	63
	64	namespace boost { namespace proto
65	{
66	namespace detail
67	{
68	////////////////////////////////////////////////////////////////////////////////////////////
69	template<typename T>
70	struct as_mutable
71	{
72	typedef T &type;
73	};
74
75	template<typename T>
76	struct as_mutable<T &>
77	{
78	typedef T &type;
79	};
80
81	template<typename T>
82	struct as_mutable<T const &>
83	{
84	typedef T &type;
85	};
86
87	////////////////////////////////////////////////////////////////////////////////////////////
88	template<typename T>
89	T make();
90
91	////////////////////////////////////////////////////////////////////////////////////////////
92	template<typename T>
93	typename as_mutable<T>::type make_mutable();
94
95	////////////////////////////////////////////////////////////////////////////////////////////
96	template<typename T>
97	struct subscript_wrapper
98	: T
99	{
100	using T::operator[];
101
102	#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
103	any operator[](any const volatile &) const volatile;
104	#else
105	any operator[](any const &) const volatile;
106	#endif
107	};
108
109	////////////////////////////////////////////////////////////////////////////////////////////
110	template<typename T>
111	struct as_subscriptable
112	{
113	typedef
114	typename mpl::if_c<
115	is_class<T>::value
116	, subscript_wrapper<T>
117	, T
118	>::type
119	type;
120	};
121
122	template<typename T>
123	struct as_subscriptable<T const>
124	{
125	typedef
126	typename mpl::if_c<
127	is_class<T>::value
128	, subscript_wrapper<T> const
129	, T const
130	>::type
131	type;
132	};
133
134	template<typename T>
135	struct as_subscriptable<T &>
136	{
137	typedef
138	typename mpl::if_c<
139	is_class<T>::value
140	, subscript_wrapper<T> &
141	, T &
142	>::type
143	type;
144	};
145
146	template<typename T>
147	struct as_subscriptable<T const &>
148	{
149	typedef
150	typename mpl::if_c<
151	is_class<T>::value
152	, subscript_wrapper<T> const &
153	, T const &
154	>::type
155	type;
156	};
157
158	////////////////////////////////////////////////////////////////////////////////////////////
159	template<typename T>
160	typename as_subscriptable<T>::type make_subscriptable();
161
162	////////////////////////////////////////////////////////////////////////////////////////////
163	template<typename T>
164	char check_reference(T &);
165
166	template<typename T>
167	char (&check_reference(T const &))[2];
168
169	namespace has_get_pointerns
170	{
171	using boost::get_pointer;
172	void *(&get_pointer(...))[2];
173
174	////////////////////////////////////////////////////////////////////////////////////////////
175	template<typename T>
176	struct has_get_pointer
177	{
178	static const bool value = sizeof(void *) == sizeof(get_pointer(make<T &>()));
179	typedef mpl::bool_<value> type;
180	};
181	}
182
183	using has_get_pointerns::has_get_pointer;
184
185	////////////////////////////////////////////////////////////////////////////////////////////
186	template<typename T>
187	struct class_member_traits;
188
189	template<typename T, typename U>
190	struct class_member_traits<T U::*>
191	{
192	typedef U class_type;
193	typedef T result_type;
194	};
195
196	// Other specializations are generated by the preprocessor
197	#include <boost/proto/detail/class_member_traits.hpp>
198
199	////////////////////////////////////////////////////////////////////////////////////////////
200	template<typename T>
201	T &lvalue(T &t)
202	{
203	return t;
204	}
205
206	template<typename T>
207	T const &lvalue(T const &t)
208	{
209	return t;
210	}
211
212	////////////////////////////////////////////////////////////////////////////////////////////
213	template<typename U, typename V, typename T>
214	U proto_get_pointer(T &t, V , U *)
215	{
216	return boost::addressof(t);
217	}
218
219	template<typename U, typename V, typename T>
220	U const proto_get_pointer(T &t, V , U const *)
221	{
222	return boost::addressof(t);
223	}
224
225	template<typename U, typename V, typename T>
226	V proto_get_pointer(T &t, V , ...)
227	{
228	return get_pointer(t);
229	}
230
231	////////////////////////////////////////////////////////////////////////////////////////////
232	#define BOOST_PROTO_USE_GET_POINTER() \
233	using namespace boost::proto::detail::get_pointerns \
234	/**/
235
236	#define BOOST_PROTO_GET_POINTER(Type, Obj) \
237	boost::proto::detail::proto_get_pointer<Type>( \
238	boost::proto::detail::lvalue(Obj) \
239	, (true ? 0 : get_pointer(Obj)) \
240	, (true ? 0 : boost::addressof(boost::proto::detail::lvalue(Obj))) \
241	) \
242	/**/
243
244	////////////////////////////////////////////////////////////////////////////////////////////
245	namespace get_pointerns
246	{
247	using boost::get_pointer;
248
249	template<typename T>
250	typename disable_if_c<has_get_pointer<T>::value, T *>::type
251	get_pointer(T &t)
252	{
253	return boost::addressof(t);
254	}
255
256	template<typename T>
257	typename disable_if_c<has_get_pointer<T>::value, T const *>::type
258	get_pointer(T const &t)
259	{
260	return boost::addressof(t);
261	}
262
263	char test_ptr_to_const(void *);
264	char (&test_ptr_to_const(void const *))[2];
265
266	template<typename U> char test_V_is_a_U(U *);
267	template<typename U> char test_V_is_a_U(U const *);
268	template<typename U> char (&test_V_is_a_U(...))[2];
269
270	////////////////////////////////////////////////////////////////////////////////////////////
271	// result_of_ is a wrapper around boost::result_of that also handles "invocations" of
272	// member object pointers.
273	template<typename T, typename Void = void>
274	struct result_of_
275	: BOOST_PROTO_RESULT_OF<T>
276	{};
277
278	template<typename T, typename U, typename V>
279	struct result_of_<T U::(V), typename enable_if_c<is_member_object_pointer<T U::>::value>::type>
280	{
281	static const bool is_V_a_smart_ptr = 2 == sizeof(test_V_is_a_U<U>(&lvalue(make<V>())));
282	static const bool is_ptr_to_const = 2 == sizeof(test_ptr_to_const(BOOST_PROTO_GET_POINTER(U, make<V>())));
283
284	// If V is not a U, then it is a (smart) pointer and we can always return an lvalue.
285	// Otherwise, we can only return an lvalue if we are given one.
286	typedef
287	typename mpl::eval_if_c<
288	(is_V_a_smart_ptr \|\| is_reference<V>::value)
289	, mpl::eval_if_c<
290	is_ptr_to_const
291	, add_reference<typename add_const<T>::type>
292	, add_reference<T>
293	>
294	, mpl::identity<T>
295	>::type
296	type;
297	};
298
299	////////////////////////////////////////////////////////////////////////////////////////////
300	template<
301	typename T
302	, typename U
303	, bool IsMemPtr = is_member_object_pointer<
304	typename remove_reference<U>::type
305	>::value
306	>
307	struct mem_ptr_fun
308	{
309	BOOST_PROTO_DECLTYPE_(
310	proto::detail::make_mutable<T>() ->* proto::detail::make<U>()
311	, result_type
312	)
313
314	result_type operator()(
315	typename add_reference<typename add_const<T>::type>::type t
316	, typename add_reference<typename add_const<U>::type>::type u
317	) const
318	{
319	return t ->* u;
320	}
321	};
322
323	////////////////////////////////////////////////////////////////////////////////////////////
324	template<typename T, typename U>
325	struct mem_ptr_fun<T, U, true>
326	{
327	typedef
328	typename class_member_traits<
329	typename uncvref<U>::type
330	>::class_type
331	V;
332
333	BOOST_PROTO_DECLTYPE_(
334	BOOST_PROTO_GET_POINTER(V, proto::detail::make_mutable<T>()) ->* proto::detail::make<U>()
335	, result_type
336	)
337
338	result_type operator()(
339	typename add_reference<typename add_const<T>::type>::type t
340	, U u
341	) const
342	{
343	return BOOST_PROTO_GET_POINTER(V, t) ->* u;
344	}
345	};
346	}
347
348	using get_pointerns::result_of_;
349	using get_pointerns::mem_ptr_fun;
350
351	////////////////////////////////////////////////////////////////////////////////////////////
352	template<typename A0, typename A1>
353	struct comma_result
354	{
355	BOOST_PROTO_DECLTYPE_((proto::detail::make<A0>(), proto::detail::make<A1>()), type)
356	};
357
358	template<typename A0>
359	struct comma_result<A0, void>
360	{
361	typedef void type;
362	};
363
364	template<typename A1>
365	struct comma_result<void, A1>
366	{
367	typedef A1 type;
368	};
369
370	template<>
371	struct comma_result<void, void>
372	{
373	typedef void type;
374	};
375
376	////////////////////////////////////////////////////////////////////////////////////////////
377	// normalize a function type for use with boost::result_of
378	template<typename T, typename U = T>
379	struct result_of_fixup
380	: mpl::if_c<is_function<T>::value, T *, U>
381	{};
382
383	template<typename T, typename U>
384	struct result_of_fixup<T &, U>
385	: result_of_fixup<T, T>
386	{};
387
388	template<typename T, typename U>
389	struct result_of_fixup<T const &, U>
390	: result_of_fixup<T, T>
391	{};
392
393	template<typename T, typename U>
394	struct result_of_fixup<T *, U>
395	: result_of_fixup<T, U>
396	{};
397
398	template<typename R, typename T, typename U>
399	struct result_of_fixup<R T::*, U>
400	{
401	typedef R T::*type;
402	};
403
404	template<typename T, typename U>
405	struct result_of_fixup<T const, U>
406	: result_of_fixup<T, U>
407	{};
408
409	//// Tests for result_of_fixup
410	//struct bar {};
411	//BOOST_MPL_ASSERT((is_same<bar, result_of_fixup<bar>::type>));
412	//BOOST_MPL_ASSERT((is_same<bar const, result_of_fixup<bar const>::type>));
413	//BOOST_MPL_ASSERT((is_same<bar, result_of_fixup<bar &>::type>));
414	//BOOST_MPL_ASSERT((is_same<bar const, result_of_fixup<bar const &>::type>));
415	//BOOST_MPL_ASSERT((is_same<void()(), result_of_fixup<void()()>::type>));
416	//BOOST_MPL_ASSERT((is_same<void()(), result_of_fixup<void( const)()>::type>));
417	//BOOST_MPL_ASSERT((is_same<void()(), result_of_fixup<void( const &)()>::type>));
418	//BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(&)()>::type>));
419
420	template<typename T, typename PMF>
421	struct memfun
422	{
423	typedef typename uncvref<PMF>::type pmf_type;
424	typedef typename class_member_traits<pmf_type>::class_type V;
425	typedef typename class_member_traits<pmf_type>::result_type result_type;
426
427	memfun(T t, pmf_type p)
428	: obj(t)
429	, pmf(p)
430	{}
431
432	result_type operator()() const
433	{
434	BOOST_PROTO_USE_GET_POINTER();
435	return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)();
436	}
437
438	// Other overloads generated by the preprocessor
439	#include <boost/proto/detail/memfun_funop.hpp>
440
441	private:
442	T obj;
443	pmf_type pmf;
444	};
445
446	} // namespace detail
447	}}
448
449	#if defined(_MSC_VER)
450	# pragma warning(pop)
451	#endif
452
453	#endif