[ceph.git] / ceph / src / boost / libs / functional / include / boost / functional / forward_adapter.hpp

/*=============================================================================
    Copyright (c) 2007-2008 Tobias Schwinger
  
    Use modification and distribution are subject to 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_FUNCTIONAL_FORWARD_ADAPTER_HPP_INCLUDED
#   ifndef BOOST_PP_IS_ITERATING

#   include <boost/config.hpp>
#   include <boost/detail/workaround.hpp>

#   include <boost/preprocessor/iteration/iterate.hpp>
#   include <boost/preprocessor/repetition/enum_params.hpp>
#   include <boost/preprocessor/repetition/enum_binary_params.hpp>
#   include <boost/preprocessor/facilities/intercept.hpp>
#   include <boost/preprocessor/arithmetic/dec.hpp>

#   include <boost/utility/result_of.hpp>

#   ifndef BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY
#     define BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY 6
#   elif BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY < 3
#     undef  BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY
#     define BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY 3
#   endif


namespace boost 
{
    template< typename Function, int Arity_Or_MinArity = -1, int MaxArity = -1 >
    class forward_adapter;

    //----- ---- --- -- - -  -   -

    namespace detail
    {
        template< class MostDerived, typename Function, typename FunctionConst, 
            int Arity, int MinArity >
        struct forward_adapter_impl;

        struct forward_adapter_result
        {
            template< typename Sig > struct apply;

            // Utility metafunction for qualification adjustment on arguments
            template< typename T > struct q          { typedef T const t; };
            template< typename T > struct q<T const> { typedef T const t; };
            template< typename T > struct q<T &>     { typedef T       t; };

            // Utility metafunction to choose target function qualification
            template< typename T > struct c
            { typedef typename T::target_function_t t; };
            template< typename T > struct c<T&      >
            { typedef typename T::target_function_t t; };
            template< typename T > struct c<T const >
            { typedef typename T::target_function_const_t t; };
            template< typename T > struct c<T const&>
            { typedef typename T::target_function_const_t t; };
        };
    }

#   define BOOST_TMP_MACRO(f,fn,fc) \
        boost::detail::forward_adapter_impl< \
            forward_adapter<f,Arity_Or_MinArity,MaxArity>, fn, fc, \
            (MaxArity!=-1? MaxArity :Arity_Or_MinArity!=-1? Arity_Or_MinArity \
                :BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY), \
            (Arity_Or_MinArity!=-1? Arity_Or_MinArity : 0) >

    template< typename Function, int Arity_Or_MinArity, int MaxArity >
    class forward_adapter
        : public BOOST_TMP_MACRO(Function,Function,Function const)
        , private Function
    {
      public:
        forward_adapter(Function const& f = Function()) 
          : Function(f) 
        { }

        typedef Function        target_function_t;
        typedef Function const  target_function_const_t;

        Function       & target_function()       { return *this; }
        Function const & target_function() const { return *this; }

        template< typename Sig > struct result
            : detail::forward_adapter_result::template apply<Sig>
        { };

        using BOOST_TMP_MACRO(Function,Function, Function const)::operator();
    };
    template< typename Function, int Arity_Or_MinArity, int MaxArity >
    class forward_adapter< Function const, Arity_Or_MinArity, MaxArity >
        : public BOOST_TMP_MACRO(Function const, Function const, Function const)
        , private Function
    {
      public:
        forward_adapter(Function const& f = Function())
          : Function(f) 
        { }

        typedef Function const target_function_t;
        typedef Function const target_function_const_t;

        Function const & target_function() const { return *this; }

        template< typename Sig > struct result
            : detail::forward_adapter_result::template apply<Sig>
        { };

        using BOOST_TMP_MACRO(Function const,Function const, Function const)
            ::operator();
    };
    template< typename Function, int Arity_Or_MinArity, int MaxArity >
    class forward_adapter< Function &, Arity_Or_MinArity, MaxArity >
        : public BOOST_TMP_MACRO(Function&, Function, Function)
    {
        Function& ref_function;
      public:
        forward_adapter(Function& f)
          : ref_function(f) 
        { }

        typedef Function target_function_t;
        typedef Function target_function_const_t;

        Function & target_function() const { return this->ref_function; }

        template< typename Sig > struct result
            : detail::forward_adapter_result::template apply<Sig>
        { };

        using BOOST_TMP_MACRO(Function&, Function, Function)::operator();
    }; 

    #undef BOOST_TMP_MACRO

    namespace detail
    {
        template< class Self >
        struct forward_adapter_result::apply< Self() >
            : boost::result_of< BOOST_DEDUCED_TYPENAME c<Self>::t() >
        { };

        // WHen operator()() doesn't have any parameters, it can't
        // be templatized and can't use SFINAE, so intead use class
        // template parameter SFINAE to decide whether to instantiate it.

        template <typename T, typename R = void>
        struct forward_adapter_sfinae
        {
            typedef T type;
        };

        // This is the fallback for when there isn't an operator()(),
        // need to create an operator() that will never instantiate
        // so that using parent::operator() will work okay.
        template< class MD, class F, class FC, class Enable = void>
        struct forward_adapter_impl_zero
        {
            template <typename T> struct never_instantiate {};
            template <typename T>
            typename never_instantiate<T>::type operator()(T) const {}
        };

        template< class MD, class F, class FC>
        struct forward_adapter_impl_zero<MD, F, FC,
            typename forward_adapter_sfinae<typename boost::result_of< FC() >::type>::type>
        {
            inline typename boost::result_of< FC() >::type
            operator()() const
            {
                return static_cast<MD const*>(this)->target_function()();
            }

            inline typename boost::result_of< F() >::type
            operator()()
            {
                return static_cast<MD*>(this)->target_function()();
            }
        };

        template< class MD, class F, class FC >
        struct forward_adapter_impl<MD,F,FC,0,0>
            : forward_adapter_impl_zero<MD,F,FC>
        {
            using forward_adapter_impl_zero<MD,F,FC>::operator();

        // closing brace gets generated by preprocessing code, below

#       define BOOST_TMP_MACRO(tpl_params,arg_types,params,args)              \
            template< tpl_params >                                             \
            inline typename boost::result_of< FC(arg_types) >::type            \
            operator()(params) const                                           \
            {                                                                  \
                return static_cast<MD const*>(this)->target_function()(args);  \
            }                                                                  \
            template< tpl_params >                                             \
            inline typename boost::result_of< F(arg_types)>::type              \
            operator()(params)                                                 \
            {                                                                  \
                return static_cast<MD*>(this)->target_function()(args);        \
            }

#       // This is the total number of iterations we need
#       define count ((1 << BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY+1)-2)

#       // Chain file iteration to virtually one loop
#       if BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY <= 7
#         define limit1 count
#         define limit2 0
#         define limit3 0
#       else
#         if BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY <= 15
#           define limit1 (count >> 8)
#           define limit2 255
#           define limit3 0
#         else
#           define limit1 (count >> 16)
#           define limit2 255
#           define limit3 255
#         endif
#       endif

#       define N 0

#       define  BOOST_PP_FILENAME_1 <boost/functional/forward_adapter.hpp>
#       define  BOOST_PP_ITERATION_LIMITS (0,limit1)
#       include BOOST_PP_ITERATE()

#       undef N
#       undef limit3
#       undef limit2
#       undef limit1
#       undef count
#       undef BOOST_TMP_MACRO

        };

    } // namespace detail

    template<class F, int A0, int A1>
    struct result_of<boost::forward_adapter<F,A0,A1> const ()>
        : boost::detail::forward_adapter_result::template apply<
            boost::forward_adapter<F,A0,A1> const () >
    { };
    template<class F, int A0, int A1>
    struct result_of<boost::forward_adapter<F,A0,A1>()>
        : boost::detail::forward_adapter_result::template apply<
            boost::forward_adapter<F,A0,A1>() >
    { };
    template<class F, int A0, int A1>
    struct result_of<boost::forward_adapter<F,A0,A1> const& ()>
        : boost::detail::forward_adapter_result::template apply<
            boost::forward_adapter<F,A0,A1> const () >
    { };
    template<class F, int A0, int A1>
    struct result_of<boost::forward_adapter<F,A0,A1>& ()>
        : boost::detail::forward_adapter_result::template apply<
            boost::forward_adapter<F,A0,A1>() >
    { };
}

#       define BOOST_FUNCTIONAL_FORWARD_ADAPTER_HPP_INCLUDED

#   elif BOOST_PP_ITERATION_DEPTH() == 1 && limit2
#     define  BOOST_PP_FILENAME_2 <boost/functional/forward_adapter.hpp>
#     define  BOOST_PP_ITERATION_LIMITS (0,limit2)
#     include BOOST_PP_ITERATE()
#   elif BOOST_PP_ITERATION_DEPTH() == 2 && limit3
#     define  BOOST_PP_FILENAME_3 <boost/functional/forward_adapter.hpp>
#     define  BOOST_PP_ITERATION_LIMITS (0,limit3)
#     include BOOST_PP_ITERATE()

#   else

#     // I is the loop counter
#     if limit2 && limit3
#       define I (BOOST_PP_ITERATION_1 << 16 | BOOST_PP_ITERATION_2 << 8 | \
            BOOST_PP_ITERATION_3)
#     elif limit2
#       define I (BOOST_PP_ITERATION_1 << 8 | BOOST_PP_ITERATION_2)
#     else
#       define I BOOST_PP_ITERATION_1
#     endif

#     if I < count

#       // Done for this arity? Increment N
#       if (I+2 >> N+1) 
#         if N == 0
#           undef N
#           define N 1
#         elif N == 1
#           undef N
#           define N 2
#         elif N == 2
#           undef N
#           define N 3
#         elif N == 3
#           undef N
#           define N 4
#         elif N == 4
#           undef N
#           define N 5
#         elif N == 5
#           undef N
#           define N 6
#         elif N == 6
#           undef N
#           define N 7
#         elif N == 7
#           undef N
#           define N 8
#         elif N == 8
#           undef N
#           define N 9
#         elif N == 9
#           undef N
#           define N 10
#         elif N == 10
#           undef N
#           define N 11
#         elif N == 11
#           undef N
#           define N 12
#         elif N == 12
#           undef N
#           define N 13
#         elif N == 13
#           undef N
#           define N 14
#         elif N == 14
#           undef N
#           define N 15
#         elif N == 15
#           undef N
#           define N 16
#         endif

        };

        template< class Self, BOOST_PP_ENUM_PARAMS(N,typename T) >
        struct forward_adapter_result::apply< Self(BOOST_PP_ENUM_PARAMS(N,T)) >
            : boost::result_of< 
                BOOST_DEDUCED_TYPENAME c<Self>::t(BOOST_PP_ENUM_BINARY_PARAMS(N, 
                      typename q<T,>::t& BOOST_PP_INTERCEPT)) >
        { };

        template< class MD, class F, class FC >
        struct forward_adapter_impl<MD,F,FC,BOOST_PP_DEC(N),N>
        {
            template< BOOST_PP_ENUM_PARAMS(N,typename T) >
            inline typename boost::result_of< F(
                BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT)) >::type
            operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT));
        };

        template< class MD, class F, class FC, int MinArity >
        struct forward_adapter_impl<MD,F,FC,N,MinArity>
            : forward_adapter_impl<MD,F,FC,BOOST_PP_DEC(N),MinArity>
        {
            using forward_adapter_impl<MD,F,FC,BOOST_PP_DEC(N),MinArity>::operator();

#       endif

#       // Zero based count for each arity would be I-(1<<N)+2, but we don't
#       // need it, unless we need a nicer order.

#       // Macros for the parameter's type modifiers.
#       if I & 0x000001
#         define PT0 T0 &
#       else
#         define PT0 T0 const &
#       endif
#       if I & 0x000002
#         define PT1 T1 &
#       else
#         define PT1 T1 const &
#       endif
#       if I & 0x000004
#         define PT2 T2 &
#       else
#         define PT2 T2 const &
#       endif
#       if I & 0x000008
#         define PT3 T3 &
#       else
#         define PT3 T3 const &
#       endif
#       if I & 0x000010
#         define PT4 T4 &
#       else
#         define PT4 T4 const &
#       endif
#       if I & 0x000020
#         define PT5 T5 &
#       else
#         define PT5 T5 const &
#       endif
#       if I & 0x000040
#         define PT6 T6 &
#       else
#         define PT6 T6 const &
#       endif
#       if I & 0x000080
#         define PT7 T7 &
#       else
#         define PT7 T7 const &
#       endif
#       if I & 0x000100
#         define PT8 T8 &
#       else
#         define PT8 T8 const &
#       endif
#       if I & 0x000200
#         define PT9 T9 &
#       else
#         define PT9 T9 const &
#       endif
#       if I & 0x000400
#         define PT10 T10 &
#       else
#         define PT10 T10 const &
#       endif
#       if I & 0x000800
#         define PT11 T11 &
#       else
#         define PT11 T11 const &
#       endif
#       if I & 0x001000
#         define PT12 T12 &
#       else
#         define PT12 T12 const &
#       endif
#       if I & 0x002000
#         define PT13 T13 &
#       else
#         define PT13 T13 const &
#       endif
#       if I & 0x004000
#         define PT14 T14 &
#       else
#         define PT14 T14 const &
#       endif
#       if I & 0x008000
#         define PT15 T15 &
#       else
#         define PT15 T15 const &
#       endif

#       if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1400)) 
            template< BOOST_PP_ENUM_PARAMS(N,typename T) >
            inline typename boost::result_of<  FC(BOOST_PP_ENUM_PARAMS(N,PT)) 
                >::type
            operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,PT,a)) const
            {
                return static_cast<MD const* const>(this)
                    ->target_function()(BOOST_PP_ENUM_PARAMS(N,a));
            }
            template< BOOST_PP_ENUM_PARAMS(N,typename T) >
            inline typename boost::result_of<  F(BOOST_PP_ENUM_PARAMS(N,PT))
                >::type
            operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,PT,a))
            {
                return static_cast<MD* const>(this)
                    ->target_function()(BOOST_PP_ENUM_PARAMS(N,a));
            }
#       else
        BOOST_TMP_MACRO(BOOST_PP_ENUM_PARAMS(N,typename T),
            BOOST_PP_ENUM_PARAMS(N,PT), BOOST_PP_ENUM_BINARY_PARAMS(N,PT,a),
            BOOST_PP_ENUM_PARAMS(N,a) )
        // ...generates uglier code but is faster - it caches ENUM_*
#       endif

#       undef PT0
#       undef PT1
#       undef PT2
#       undef PT3
#       undef PT4
#       undef PT5
#       undef PT6
#       undef PT7
#       undef PT8
#       undef PT9
#       undef PT10
#       undef PT11
#       undef PT12
#       undef PT13
#       undef PT14
#       undef PT15

#     endif // I < count

#     undef I
#   endif // defined(BOOST_PP_IS_ITERATING)

#endif // include guard
Commit	Line	Data
7c673cae FG	1	/*=============================================================================
	2	Copyright (c) 2007-2008 Tobias Schwinger
	3
	4	Use modification and distribution are subject to the Boost Software
	5	License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
	6	http://www.boost.org/LICENSE_1_0.txt).
	7	==============================================================================*/
	8
	9	#ifndef BOOST_FUNCTIONAL_FORWARD_ADAPTER_HPP_INCLUDED
	10	# ifndef BOOST_PP_IS_ITERATING
	11
	12	# include <boost/config.hpp>
	13	# include <boost/detail/workaround.hpp>
	14
	15	# include <boost/preprocessor/iteration/iterate.hpp>
	16	# include <boost/preprocessor/repetition/enum_params.hpp>
	17	# include <boost/preprocessor/repetition/enum_binary_params.hpp>
	18	# include <boost/preprocessor/facilities/intercept.hpp>
	19	# include <boost/preprocessor/arithmetic/dec.hpp>
	20
	21	# include <boost/utility/result_of.hpp>
	22
	23	# ifndef BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY
	24	# define BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY 6
	25	# elif BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY < 3
	26	# undef BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY
	27	# define BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY 3
	28	# endif
	29
	30
	31	namespace boost
	32	{
	33	template< typename Function, int Arity_Or_MinArity = -1, int MaxArity = -1 >
	34	class forward_adapter;
	35
	36	//----- ---- --- -- - - - -
	37
	38	namespace detail
	39	{
	40	template< class MostDerived, typename Function, typename FunctionConst,
	41	int Arity, int MinArity >
	42	struct forward_adapter_impl;
	43
	44	struct forward_adapter_result
	45	{
	46	template< typename Sig > struct apply;
	47
	48	// Utility metafunction for qualification adjustment on arguments
	49	template< typename T > struct q { typedef T const t; };
	50	template< typename T > struct q<T const> { typedef T const t; };
	51	template< typename T > struct q<T &> { typedef T t; };
	52
	53	// Utility metafunction to choose target function qualification
	54	template< typename T > struct c
	55	{ typedef typename T::target_function_t t; };
	56	template< typename T > struct c<T& >
	57	{ typedef typename T::target_function_t t; };
	58	template< typename T > struct c<T const >
	59	{ typedef typename T::target_function_const_t t; };
	60	template< typename T > struct c<T const&>
	61	{ typedef typename T::target_function_const_t t; };
	62	};
	63	}
	64
65	# define BOOST_TMP_MACRO(f,fn,fc) \
66	boost::detail::forward_adapter_impl< \
67	forward_adapter<f,Arity_Or_MinArity,MaxArity>, fn, fc, \
68	(MaxArity!=-1? MaxArity :Arity_Or_MinArity!=-1? Arity_Or_MinArity \
69	:BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY), \
70	(Arity_Or_MinArity!=-1? Arity_Or_MinArity : 0) >
71
72	template< typename Function, int Arity_Or_MinArity, int MaxArity >
73	class forward_adapter
74	: public BOOST_TMP_MACRO(Function,Function,Function const)
75	, private Function
76	{
77	public:
78	forward_adapter(Function const& f = Function())
79	: Function(f)
80	{ }
81
82	typedef Function target_function_t;
83	typedef Function const target_function_const_t;
84
85	Function & target_function() { return *this; }
86	Function const & target_function() const { return *this; }
87
88	template< typename Sig > struct result
89	: detail::forward_adapter_result::template apply<Sig>
90	{ };
91
92	using BOOST_TMP_MACRO(Function,Function, Function const)::operator();
93	};
94	template< typename Function, int Arity_Or_MinArity, int MaxArity >
95	class forward_adapter< Function const, Arity_Or_MinArity, MaxArity >
96	: public BOOST_TMP_MACRO(Function const, Function const, Function const)
97	, private Function
98	{
99	public:
100	forward_adapter(Function const& f = Function())
101	: Function(f)
102	{ }
103
104	typedef Function const target_function_t;
105	typedef Function const target_function_const_t;
106
107	Function const & target_function() const { return *this; }
108
109	template< typename Sig > struct result
110	: detail::forward_adapter_result::template apply<Sig>
111	{ };
112
113	using BOOST_TMP_MACRO(Function const,Function const, Function const)
114	::operator();
115	};
116	template< typename Function, int Arity_Or_MinArity, int MaxArity >
117	class forward_adapter< Function &, Arity_Or_MinArity, MaxArity >
118	: public BOOST_TMP_MACRO(Function&, Function, Function)
119	{
120	Function& ref_function;
121	public:
122	forward_adapter(Function& f)
123	: ref_function(f)
124	{ }
125
126	typedef Function target_function_t;
127	typedef Function target_function_const_t;
128
129	Function & target_function() const { return this->ref_function; }
130
131	template< typename Sig > struct result
132	: detail::forward_adapter_result::template apply<Sig>
133	{ };
134
135	using BOOST_TMP_MACRO(Function&, Function, Function)::operator();
136	};
137
138	#undef BOOST_TMP_MACRO
139
140	namespace detail
141	{
142	template< class Self >
143	struct forward_adapter_result::apply< Self() >
144	: boost::result_of< BOOST_DEDUCED_TYPENAME c<Self>::t() >
145	{ };
146
147	// WHen operator()() doesn't have any parameters, it can't
148	// be templatized and can't use SFINAE, so intead use class
149	// template parameter SFINAE to decide whether to instantiate it.
150
151	template <typename T, typename R = void>
152	struct forward_adapter_sfinae
153	{
154	typedef T type;
155	};
156
157	// This is the fallback for when there isn't an operator()(),
158	// need to create an operator() that will never instantiate
159	// so that using parent::operator() will work okay.
160	template< class MD, class F, class FC, class Enable = void>
161	struct forward_adapter_impl_zero
162	{
163	template <typename T> struct never_instantiate {};
164	template <typename T>
165	typename never_instantiate<T>::type operator()(T) const {}
166	};
167
168	template< class MD, class F, class FC>
169	struct forward_adapter_impl_zero<MD, F, FC,
170	typename forward_adapter_sfinae<typename boost::result_of< FC() >::type>::type>
171	{
172	inline typename boost::result_of< FC() >::type
173	operator()() const
174	{
175	return static_cast<MD const*>(this)->target_function()();
176	}
177
178	inline typename boost::result_of< F() >::type
179	operator()()
180	{
181	return static_cast<MD*>(this)->target_function()();
182	}
183	};
184
185	template< class MD, class F, class FC >
186	struct forward_adapter_impl<MD,F,FC,0,0>
187	: forward_adapter_impl_zero<MD,F,FC>
188	{
189	using forward_adapter_impl_zero<MD,F,FC>::operator();
190
191	// closing brace gets generated by preprocessing code, below
192
193	# define BOOST_TMP_MACRO(tpl_params,arg_types,params,args) \
194	template< tpl_params > \
195	inline typename boost::result_of< FC(arg_types) >::type \
196	operator()(params) const \
197	{ \
198	return static_cast<MD const*>(this)->target_function()(args); \
199	} \
200	template< tpl_params > \
201	inline typename boost::result_of< F(arg_types)>::type \
202	operator()(params) \
203	{ \
204	return static_cast<MD*>(this)->target_function()(args); \
205	}
206
207	# // This is the total number of iterations we need
208	# define count ((1 << BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY+1)-2)
209
210	# // Chain file iteration to virtually one loop
211	# if BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY <= 7
212	# define limit1 count
213	# define limit2 0
214	# define limit3 0
215	# else
216	# if BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY <= 15
217	# define limit1 (count >> 8)
218	# define limit2 255
219	# define limit3 0
220	# else
221	# define limit1 (count >> 16)
222	# define limit2 255
223	# define limit3 255
224	# endif
225	# endif
226
227	# define N 0
228
229	# define BOOST_PP_FILENAME_1 <boost/functional/forward_adapter.hpp>
230	# define BOOST_PP_ITERATION_LIMITS (0,limit1)
231	# include BOOST_PP_ITERATE()
232
233	# undef N
234	# undef limit3
235	# undef limit2
236	# undef limit1
237	# undef count
238	# undef BOOST_TMP_MACRO
239
240	};
241
242	} // namespace detail
243
244	template<class F, int A0, int A1>
245	struct result_of<boost::forward_adapter<F,A0,A1> const ()>
246	: boost::detail::forward_adapter_result::template apply<
247	boost::forward_adapter<F,A0,A1> const () >
248	{ };
249	template<class F, int A0, int A1>
250	struct result_of<boost::forward_adapter<F,A0,A1>()>
251	: boost::detail::forward_adapter_result::template apply<
252	boost::forward_adapter<F,A0,A1>() >
253	{ };
254	template<class F, int A0, int A1>
255	struct result_of<boost::forward_adapter<F,A0,A1> const& ()>
256	: boost::detail::forward_adapter_result::template apply<
257	boost::forward_adapter<F,A0,A1> const () >
258	{ };
259	template<class F, int A0, int A1>
260	struct result_of<boost::forward_adapter<F,A0,A1>& ()>
261	: boost::detail::forward_adapter_result::template apply<
262	boost::forward_adapter<F,A0,A1>() >
263	{ };
264	}
265
266	# define BOOST_FUNCTIONAL_FORWARD_ADAPTER_HPP_INCLUDED
267
268	# elif BOOST_PP_ITERATION_DEPTH() == 1 && limit2
269	# define BOOST_PP_FILENAME_2 <boost/functional/forward_adapter.hpp>
270	# define BOOST_PP_ITERATION_LIMITS (0,limit2)
271	# include BOOST_PP_ITERATE()
272	# elif BOOST_PP_ITERATION_DEPTH() == 2 && limit3
273	# define BOOST_PP_FILENAME_3 <boost/functional/forward_adapter.hpp>
274	# define BOOST_PP_ITERATION_LIMITS (0,limit3)
275	# include BOOST_PP_ITERATE()
276
277	# else
278
279	# // I is the loop counter
280	# if limit2 && limit3
281	# define I (BOOST_PP_ITERATION_1 << 16 \| BOOST_PP_ITERATION_2 << 8 \| \
282	BOOST_PP_ITERATION_3)
283	# elif limit2
284	# define I (BOOST_PP_ITERATION_1 << 8 \| BOOST_PP_ITERATION_2)
285	# else
286	# define I BOOST_PP_ITERATION_1
287	# endif
288
289	# if I < count
290
291	# // Done for this arity? Increment N
292	# if (I+2 >> N+1)
293	# if N == 0
294	# undef N
295	# define N 1
296	# elif N == 1
297	# undef N
298	# define N 2
299	# elif N == 2
300	# undef N
301	# define N 3
302	# elif N == 3
303	# undef N
304	# define N 4
305	# elif N == 4
306	# undef N
307	# define N 5
308	# elif N == 5
309	# undef N
310	# define N 6
311	# elif N == 6
312	# undef N
313	# define N 7
314	# elif N == 7
315	# undef N
316	# define N 8
317	# elif N == 8
318	# undef N
319	# define N 9
320	# elif N == 9
321	# undef N
322	# define N 10
323	# elif N == 10
324	# undef N
325	# define N 11
326	# elif N == 11
327	# undef N
328	# define N 12
329	# elif N == 12
330	# undef N
331	# define N 13
332	# elif N == 13
333	# undef N
334	# define N 14
335	# elif N == 14
336	# undef N
337	# define N 15
338	# elif N == 15
339	# undef N
340	# define N 16
341	# endif
342
343	};
344
345	template< class Self, BOOST_PP_ENUM_PARAMS(N,typename T) >
346	struct forward_adapter_result::apply< Self(BOOST_PP_ENUM_PARAMS(N,T)) >
347	: boost::result_of<
348	BOOST_DEDUCED_TYPENAME c<Self>::t(BOOST_PP_ENUM_BINARY_PARAMS(N,
349	typename q<T,>::t& BOOST_PP_INTERCEPT)) >
350	{ };
351
352	template< class MD, class F, class FC >
353	struct forward_adapter_impl<MD,F,FC,BOOST_PP_DEC(N),N>
354	{
355	template< BOOST_PP_ENUM_PARAMS(N,typename T) >
356	inline typename boost::result_of< F(
357	BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT)) >::type
358	operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,T,& BOOST_PP_INTERCEPT));
359	};
360
361	template< class MD, class F, class FC, int MinArity >
362	struct forward_adapter_impl<MD,F,FC,N,MinArity>
363	: forward_adapter_impl<MD,F,FC,BOOST_PP_DEC(N),MinArity>
364	{
365	using forward_adapter_impl<MD,F,FC,BOOST_PP_DEC(N),MinArity>::operator();
366
367	# endif
368
369	# // Zero based count for each arity would be I-(1<<N)+2, but we don't
370	# // need it, unless we need a nicer order.
371
372	# // Macros for the parameter's type modifiers.
373	# if I & 0x000001
374	# define PT0 T0 &
375	# else
376	# define PT0 T0 const &
377	# endif
378	# if I & 0x000002
379	# define PT1 T1 &
380	# else
381	# define PT1 T1 const &
382	# endif
383	# if I & 0x000004
384	# define PT2 T2 &
385	# else
386	# define PT2 T2 const &
387	# endif
388	# if I & 0x000008
389	# define PT3 T3 &
390	# else
391	# define PT3 T3 const &
392	# endif
393	# if I & 0x000010
394	# define PT4 T4 &
395	# else
396	# define PT4 T4 const &
397	# endif
398	# if I & 0x000020
399	# define PT5 T5 &
400	# else
401	# define PT5 T5 const &
402	# endif
403	# if I & 0x000040
404	# define PT6 T6 &
405	# else
406	# define PT6 T6 const &
407	# endif
408	# if I & 0x000080
409	# define PT7 T7 &
410	# else
411	# define PT7 T7 const &
412	# endif
413	# if I & 0x000100
414	# define PT8 T8 &
415	# else
416	# define PT8 T8 const &
417	# endif
418	# if I & 0x000200
419	# define PT9 T9 &
420	# else
421	# define PT9 T9 const &
422	# endif
423	# if I & 0x000400
424	# define PT10 T10 &
425	# else
426	# define PT10 T10 const &
427	# endif
428	# if I & 0x000800
429	# define PT11 T11 &
430	# else
431	# define PT11 T11 const &
432	# endif
433	# if I & 0x001000
434	# define PT12 T12 &
435	# else
436	# define PT12 T12 const &
437	# endif
438	# if I & 0x002000
439	# define PT13 T13 &
440	# else
441	# define PT13 T13 const &
442	# endif
443	# if I & 0x004000
444	# define PT14 T14 &
445	# else
446	# define PT14 T14 const &
447	# endif
448	# if I & 0x008000
449	# define PT15 T15 &
450	# else
451	# define PT15 T15 const &
452	# endif
453
454	# if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1400))
455	template< BOOST_PP_ENUM_PARAMS(N,typename T) >
456	inline typename boost::result_of< FC(BOOST_PP_ENUM_PARAMS(N,PT))
457	>::type
458	operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,PT,a)) const
459	{
460	return static_cast<MD const* const>(this)
461	->target_function()(BOOST_PP_ENUM_PARAMS(N,a));
462	}
463	template< BOOST_PP_ENUM_PARAMS(N,typename T) >
464	inline typename boost::result_of< F(BOOST_PP_ENUM_PARAMS(N,PT))
465	>::type
466	operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,PT,a))
467	{
468	return static_cast<MD* const>(this)
469	->target_function()(BOOST_PP_ENUM_PARAMS(N,a));
470	}
471	# else
472	BOOST_TMP_MACRO(BOOST_PP_ENUM_PARAMS(N,typename T),
473	BOOST_PP_ENUM_PARAMS(N,PT), BOOST_PP_ENUM_BINARY_PARAMS(N,PT,a),
474	BOOST_PP_ENUM_PARAMS(N,a) )
475	// ...generates uglier code but is faster - it caches ENUM_*
476	# endif
477
478	# undef PT0
479	# undef PT1
480	# undef PT2
481	# undef PT3
482	# undef PT4
483	# undef PT5
484	# undef PT6
485	# undef PT7
486	# undef PT8
487	# undef PT9
488	# undef PT10
489	# undef PT11
490	# undef PT12
491	# undef PT13
492	# undef PT14
493	# undef PT15
494
495	# endif // I < count
496
497	# undef I
498	# endif // defined(BOOST_PP_IS_ITERATING)
499
500	#endif // include guard
501