+/*==============================================================================

+ Copyright (c) 2001-2010 Joel de Guzman

+

+ 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_PHOENIX_BIND_HPP

+#define BOOST_PHOENIX_BIND_HPP

+

+#ifdef BOOST_PHOENIX_USE_V2_OVER_V3

+#include <boost/spirit/home/phoenix/core.hpp>

+#else

+#include <boost/phoenix/version.hpp>

+#include <boost/phoenix/bind/bind_function.hpp>

+#include <boost/phoenix/bind/bind_function_object.hpp>

+#include <boost/phoenix/bind/bind_member_function.hpp>

+#include <boost/phoenix/bind/bind_member_variable.hpp>

+#endif

+

+#endif

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+#if !BOOST_PHOENIX_IS_ITERATING

+

+#ifndef PHOENIX_BIND_BIND_FUNCTION_HPP

+#define PHOENIX_BIND_BIND_FUNCTION_HPP

+

+#include <boost/phoenix/core/expression.hpp>

+#include <boost/phoenix/core/detail/function_eval.hpp>

+#include <boost/phoenix/bind/detail/function_ptr.hpp>

+

+namespace boost { namespace phoenix {

+

+ template <

+ typename RT

+ >

+ inline

+ typename detail::expression::function_eval<

+ detail::function_ptr<0, RT, RT(*)()>

+ >::type const

+ bind(RT(*f)())

+ {

+ typedef detail::function_ptr<0, RT, RT(*)()> fp_type;

+ return detail::expression::function_eval<fp_type>::make(fp_type(f));

+ }

+

+ template <

+ typename RT

+ , typename T0

+ , typename A0

+ >

+ inline

+ typename detail::expression::function_eval<

+ detail::function_ptr<1, RT, RT(*)(T0)>

+ , A0

+ >::type const

+ bind(RT(*f)(T0), A0 const & a0)

+ {

+ typedef detail::function_ptr<1, RT, RT(*)(T0)> fp_type;

+ return detail::expression::function_eval<fp_type, A0>::make(fp_type(f), a0);

+ }

+

+#if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)

+ #include <boost/phoenix/bind/preprocessed/bind_function.hpp>

+#else

+

+#if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(preserve: 2, line: 0, output: "preprocessed/bind_function_" BOOST_PHOENIX_LIMIT_STR ".hpp")

+#endif

+

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(preserve: 1)

+#endif

+

+#define BOOST_PHOENIX_ITERATION_PARAMS \

+ (3, (2, BOOST_PP_DEC(BOOST_PHOENIX_ACTOR_LIMIT), \

+ <boost/phoenix/bind/bind_function.hpp>))

+#include BOOST_PHOENIX_ITERATE()

+

+#if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(output: null)

+#endif

+

+#endif

+

+}}

+

+#endif

+

+#else

+

+ template <

+ typename RT

+ , BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, typename T)

+ , BOOST_PHOENIX_typename_A

+ >

+ inline

+ typename detail::expression::function_eval<

+ detail::function_ptr<

+ BOOST_PHOENIX_ITERATION

+ , RT

+ , RT(*)(BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, T))

+ >

+ , BOOST_PHOENIX_A

+ >::type const

+ bind(

+ RT(*f)(BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, T))

+ , BOOST_PHOENIX_A_const_ref_a

+ )

+ {

+ typedef detail::function_ptr<

+ BOOST_PHOENIX_ITERATION

+ , RT

+ , RT(*)(BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, T))

+ > fp_type;

+ return

+ detail::expression::function_eval<

+ fp_type

+ , BOOST_PHOENIX_A

+ >::make(

+ fp_type(f)

+ , BOOST_PHOENIX_a

+ );

+ }

+

+#endif

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+#if !BOOST_PHOENIX_IS_ITERATING

+

+#ifndef PHOENIX_BIND_BIND_FUNCTION_OBJECT_HPP

+#define PHOENIX_BIND_BIND_FUNCTION_OBJECT_HPP

+

+#include <boost/phoenix/core/expression.hpp>

+#include <boost/phoenix/core/detail/function_eval.hpp>

+

+namespace boost { namespace phoenix {

+ template <typename F>

+ inline

+ typename detail::expression::function_eval<F>::type const

+ bind(F f)

+ {

+ return detail::expression::function_eval<F>::make(f);

+ }

+

+#if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)

+ #include <boost/phoenix/bind/preprocessed/bind_function_object.hpp>

+#else

+

+#if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(preserve: 2, line: 0, output: "preprocessed/bind_function_object_" BOOST_PHOENIX_LIMIT_STR ".hpp")

+#endif

+

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(preserve: 1)

+#endif

+

+#define BOOST_PHOENIX_ITERATION_PARAMS \

+ (3, (1, BOOST_PP_DEC(BOOST_PHOENIX_ACTOR_LIMIT), \

+ <boost/phoenix/bind/bind_function_object.hpp>))

+#include BOOST_PHOENIX_ITERATE()

+

+#if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(output: null)

+#endif

+

+#endif

+

+}}

+

+#endif

+

+#else

+

+ template <

+ typename F

+ , BOOST_PHOENIX_typename_A

+ >

+ inline

+ typename detail::expression::function_eval<

+ F

+ , BOOST_PHOENIX_A

+ >::type const

+ bind(F f, BOOST_PHOENIX_A_const_ref_a)

+ {

+ return

+ detail::expression::function_eval<F, BOOST_PHOENIX_A>::make(

+ f

+ , BOOST_PHOENIX_a

+ );

+ }

+

+#endif

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+#if !BOOST_PHOENIX_IS_ITERATING

+

+#ifndef PHOENIX_BIND_BIND_MEMBER_FUNCTION_HPP

+#define PHOENIX_BIND_BIND_MEMBER_FUNCTION_HPP

+

+#include <boost/phoenix/core/expression.hpp>

+#include <boost/phoenix/core/reference.hpp>

+#include <boost/phoenix/core/detail/function_eval.hpp>

+#include <boost/phoenix/bind/detail/member_function_ptr.hpp>

+

+namespace boost { namespace phoenix

+{

+

+ template <typename RT, typename ClassT, typename ClassA>

+ inline typename detail::expression::function_eval<

+ detail::member_function_ptr<0, RT, RT(ClassT::*)()>

+ , ClassA

+ >::type const

+ bind(RT(ClassT::*f)(), ClassA const& obj)

+ {

+ typedef detail::member_function_ptr<0, RT, RT(ClassT::*)()> fp_type;

+ return

+ detail::expression::function_eval<fp_type, ClassA>::make(

+ fp_type(f)

+ , obj

+ );

+ }

+

+ template <typename RT, typename ClassT, typename ClassA>

+ inline typename detail::expression::function_eval<

+ detail::member_function_ptr<0, RT, RT(ClassT::*)() const>

+ , ClassA

+ >::type const

+ bind(RT(ClassT::*f)() const, ClassA const& obj)

+ {

+ typedef

+ detail::member_function_ptr<0, RT, RT(ClassT::*)() const>

+ fp_type;

+ return

+ detail::expression::function_eval<fp_type, ClassA>::make(

+ fp_type(f)

+ , obj

+ );

+ }

+

+ template <typename RT, typename ClassT>

+ inline typename detail::expression::function_eval<

+ detail::member_function_ptr<0, RT, RT(ClassT::*)()>

+ , ClassT

+ >::type const

+ bind(RT(ClassT::*f)(), ClassT& obj)

+ {

+ typedef detail::member_function_ptr<0, RT, RT(ClassT::*)()> fp_type;

+ return

+ detail::expression::function_eval<

+ fp_type

+ , ClassT

+ >::make(

+ fp_type(f)

+ , obj

+ );

+ }

+

+ template <typename RT, typename ClassT>

+ inline typename detail::expression::function_eval<

+ detail::member_function_ptr<0, RT, RT(ClassT::*)() const>

+ , ClassT

+ >::type const

+ bind(RT(ClassT::*f)() const, ClassT& obj)

+ {

+ typedef detail::member_function_ptr<0, RT, RT(ClassT::*)() const> fp_type;

+ return

+ detail::expression::function_eval<

+ fp_type

+ , ClassT

+ >::make(

+ fp_type(f)

+ , obj

+ );

+ }

+

+#if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)

+ #include <boost/phoenix/bind/preprocessed/bind_member_function.hpp>

+#else

+

+#if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(preserve: 2, line: 0, output: "preprocessed/bind_member_function_" BOOST_PHOENIX_LIMIT_STR ".hpp")

+#endif

+

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(preserve: 1)

+#endif

+

+#define BOOST_PHOENIX_ITERATION_PARAMS \

+ (3, (1, BOOST_PP_DEC(BOOST_PHOENIX_ACTOR_LIMIT), \

+ <boost/phoenix/bind/bind_member_function.hpp>))

+#include BOOST_PHOENIX_ITERATE()

+

+#if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(output: null)

+#endif

+

+#endif

+

+}}

+

+#endif

+

+#else

+

+ template <

+ typename RT

+ , typename ClassT

+ , BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, typename T)

+ , typename ClassA

+ , BOOST_PHOENIX_typename_A

+ >

+ inline

+ typename detail::expression::function_eval<

+ detail::member_function_ptr<

+ BOOST_PHOENIX_ITERATION

+ , RT

+ , RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, T))

+ >

+ , ClassA

+ , BOOST_PHOENIX_A

+ >::type const

+ bind(

+ RT(ClassT::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, T))

+ , ClassA const & obj

+ , BOOST_PHOENIX_A_const_ref_a

+ )

+ {

+ typedef detail::member_function_ptr<

+ BOOST_PHOENIX_ITERATION

+ , RT

+ , RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, T))

+ > fp_type;

+ return

+ detail::expression::function_eval<

+ fp_type

+ , ClassA

+ , BOOST_PHOENIX_A

+ >::make(

+ fp_type(f)

+ , obj

+ , BOOST_PHOENIX_a

+ );

+ }

+

+ template <

+ typename RT

+ , typename ClassT

+ , BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, typename T)

+ , typename ClassA

+ , BOOST_PHOENIX_typename_A

+ >

+ inline

+ typename detail::expression::function_eval<

+ detail::member_function_ptr<

+ BOOST_PHOENIX_ITERATION

+ , RT

+ , RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, T)) const

+ >

+ , ClassA

+ , BOOST_PHOENIX_A

+ >::type const

+ bind(

+ RT(ClassT::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, T)) const

+ , ClassA const & obj

+ , BOOST_PHOENIX_A_const_ref_a

+ )

+ {

+ typedef detail::member_function_ptr<

+ BOOST_PHOENIX_ITERATION

+ , RT

+ , RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, T)) const

+ > fp_type;

+ return

+ detail::expression::function_eval<

+ fp_type

+ , ClassA

+ , BOOST_PHOENIX_A

+ >::make(

+ fp_type(f)

+ , obj

+ , BOOST_PHOENIX_a

+ );

+ }

+

+ template <

+ typename RT

+ , typename ClassT

+ , BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, typename T)

+ , BOOST_PHOENIX_typename_A

+ >

+ inline

+ typename detail::expression::function_eval<

+ detail::member_function_ptr<

+ BOOST_PHOENIX_ITERATION

+ , RT

+ , RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, T))

+ >

+ , ClassT

+ , BOOST_PHOENIX_A

+ >::type const

+ bind(

+ RT(ClassT::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, T))

+ , ClassT & obj

+ , BOOST_PHOENIX_A_const_ref_a

+ )

+ {

+ typedef detail::member_function_ptr<

+ BOOST_PHOENIX_ITERATION

+ , RT

+ , RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(BOOST_PHOENIX_ITERATION, T))

+ > fp_type;

+ return

+ detail::expression::function_eval<

+ fp_type

+ , ClassT

+ , BOOST_PHOENIX_A

+ >::make(

+ fp_type(f)

+ , obj

+ , BOOST_PHOENIX_a

+ );

+ }

+

+#endif

+

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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 PHOENIX_BIND_BIND_MEMBER_VARIABLE_HPP

+#define PHOENIX_BIND_BIND_MEMBER_VARIABLE_HPP

+

+#include <boost/phoenix/core/expression.hpp>

+#include <boost/phoenix/core/detail/function_eval.hpp>

+#include <boost/phoenix/bind/detail/member_variable.hpp>

+

+namespace boost { namespace phoenix

+{

+ template <typename RT, typename ClassT, typename ClassA>

+ inline typename

+ detail::expression::function_eval<

+ detail::member_variable<RT, RT ClassT::*>

+ , ClassA

+ >::type const

+ bind(RT ClassT::*mp, ClassA const& obj)

+ {

+ typedef detail::member_variable<RT, RT ClassT::*> mp_type;

+ return

+ detail::expression::function_eval<mp_type, ClassA>

+ ::make(mp_type(mp), obj);

+ }

+

+ template <typename RT, typename ClassT>

+ inline typename

+ detail::expression::function_eval<

+ detail::member_variable<RT, RT ClassT::*>

+ , ClassT

+ >::type const

+ bind(RT ClassT::*mp, ClassT& obj)

+ {

+ typedef detail::member_variable<RT, RT ClassT::*> mp_type;

+ return

+ detail::expression::function_eval<

+ mp_type

+ , ClassT

+ >::make(mp_type(mp), obj);

+ }

+

+}}

+

+#endif

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+#if !BOOST_PHOENIX_IS_ITERATING

+

+#ifndef BOOST_PHOENIX_BIND_DETAIL_FUNCTION_PTR_HPP

+#define BOOST_PHOENIX_BIND_DETAIL_FUNCTION_PTR_HPP

+

+#include <boost/phoenix/core/limits.hpp>

+#include <boost/phoenix/support/iterate.hpp>

+

+namespace boost { namespace phoenix { namespace detail

+{

+ template <int N, typename Dummy = void>

+ struct function_ptr_impl

+ {

+ template <typename RT, typename FP>

+ struct impl;

+ };

+

+ template <int N, typename RT, typename FP>

+ struct function_ptr : function_ptr_impl<N>::template impl<RT, FP>

+ {

+ typedef typename function_ptr_impl<N>::template impl<RT, FP> base;

+

+ function_ptr(FP fp)

+ : base(fp) {}

+

+ using base::fp;

+

+ bool operator==(function_ptr const & rhs) const

+ {

+ return fp == rhs.fp;

+ }

+

+ template <int M, typename RhsRT, typename RhsFP>

+ bool operator==(function_ptr<M, RhsRT, RhsFP> const & rhs) const

+ {

+ return false;

+ }

+

+ };

+

+ template <typename Dummy>

+ struct function_ptr_impl<0, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+

+ impl(FP fp)

+ : fp(fp) {}

+

+ RT operator()() const

+ {

+ return fp();

+ }

+

+ FP fp;

+ };

+ };

+

+ template <typename Dummy>

+ struct function_ptr_impl<1, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+

+ impl(FP fp)

+ : fp(fp) {}

+

+ template <typename A>

+ RT operator()(A &a) const

+ {

+ return fp(a);

+ }

+

+ FP fp;

+ };

+ };

+

+#if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)

+ #include <boost/phoenix/bind/detail/preprocessed/function_ptr.hpp>

+#else

+

+#if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(preserve: 2, line: 0, output: "preprocessed/function_ptr_" BOOST_PHOENIX_LIMIT_STR ".hpp")

+#endif

+

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(preserve: 1)

+#endif

+

+#define BOOST_PHOENIX_ITERATION_PARAMS \

+ (3, (2, BOOST_PHOENIX_COMPOSITE_LIMIT, \

+ <boost/phoenix/bind/detail/function_ptr.hpp>))

+#include BOOST_PHOENIX_ITERATE()

+

+#if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(output: null)

+#endif

+

+#endif

+

+}}} // namespace boost::phoenix::detail

+

+#endif

+

+///////////////////////////////////////////////////////////////////////////////

+//

+// Preprocessor vertical repetition code

+//

+///////////////////////////////////////////////////////////////////////////////

+#else // defined(BOOST_PP_IS_ITERATING)

+

+ template <typename Dummy>

+ struct function_ptr_impl<BOOST_PHOENIX_ITERATION, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+

+ impl(FP fp)

+ : fp(fp) {}

+

+ template <BOOST_PHOENIX_typename_A>

+ RT operator()(BOOST_PHOENIX_A_ref_a) const

+ {

+ return fp(BOOST_PHOENIX_a);

+ }

+

+ FP fp;

+ };

+ };

+

+#endif // defined(BOOST_PP_IS_ITERATING)

+/*=============================================================================

+Copyright (c) 2001-2007 Joel de Guzman

+

+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)

+==============================================================================*/

+

+#if !BOOST_PHOENIX_IS_ITERATING

+

+#ifndef BOOST_PHOENIX_BIND_DETAIL_MEMBER_FUNCTION_PTR_HPP

+#define BOOST_PHOENIX_BIND_DETAIL_MEMBER_FUNCTION_PTR_HPP

+

+#include <boost/phoenix/core/limits.hpp>

+#include <boost/phoenix/support/iterate.hpp>

+

+namespace boost { namespace phoenix { namespace detail

+{

+ template <int N>

+ struct member_function_ptr_impl

+ {

+ template <typename RT, typename FP>

+ struct impl;

+ };

+

+ template <int N, typename RT, typename FP>

+ struct member_function_ptr

+ : member_function_ptr_impl<N>::template impl<RT, FP>

+ {

+ typedef typename member_function_ptr_impl<N>::

+ template impl<RT, FP> base;

+ member_function_ptr(FP fp)

+ : base(fp) {}

+

+ using base::fp;

+

+ bool operator==(member_function_ptr const & rhs) const

+ {

+ return fp == rhs.fp;

+ }

+

+ template <int M, typename RhsRT, typename RhsFP>

+ bool operator==(member_function_ptr<M, RhsRT, RhsFP> const & rhs) const

+ {

+ return false;

+ }

+ };

+

+ template <>

+ struct member_function_ptr_impl<0>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+

+ impl(FP fp)

+ : fp(fp) {}

+

+ template <typename Class>

+ RT operator()(Class& obj) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj) ->*fp)();

+ }

+

+ template <typename Class>

+ RT operator()(Class* obj) const

+ {

+ return (obj->*fp)();

+ }

+

+ FP fp;

+ };

+ };

+

+#if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)

+ #include <boost/phoenix/bind/detail/preprocessed/member_function_ptr.hpp>

+#else

+

+#if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(preserve: 2, line: 0, output: "preprocessed/member_function_ptr_" BOOST_PHOENIX_LIMIT_STR ".hpp")

+#endif

+

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(preserve: 1)

+#endif

+

+#define BOOST_PHOENIX_ITERATION_PARAMS \

+ (3, (1, BOOST_PHOENIX_COMPOSITE_LIMIT, \

+ <boost/phoenix/bind/detail/member_function_ptr.hpp>))

+#include BOOST_PHOENIX_ITERATE()

+

+#if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)

+ #pragma wave option(output: null)

+#endif

+

+#endif

+

+}}} // namespace boost::phoenix::detail

+

+#endif

+

+///////////////////////////////////////////////////////////////////////////////

+//

+// Preprocessor vertical repetition code

+//

+///////////////////////////////////////////////////////////////////////////////

+#else

+

+ template <>

+ struct member_function_ptr_impl<BOOST_PHOENIX_ITERATION>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+

+ impl(FP fp)

+ : fp(fp) {}

+

+ template <typename Class, BOOST_PHOENIX_typename_A>

+ RT operator()(Class& obj, BOOST_PHOENIX_A_ref_a) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(BOOST_PHOENIX_a);

+ }

+

+ template <typename Class, BOOST_PHOENIX_typename_A>

+ RT operator()(Class* obj, BOOST_PHOENIX_A_ref_a) const

+ {

+ return (obj->*fp)(BOOST_PHOENIX_a);

+ }

+

+ FP fp;

+ };

+ };

+

+#endif // defined(BOOST_PP_IS_ITERATING)

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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_PHOENIX_CORE_DETAIL_MEMBER_VARIABLE_HPP

+#define BOOST_PHOENIX_CORE_DETAIL_MEMBER_VARIABLE_HPP

+

+#include <boost/proto/detail/decltype.hpp>

+#include <boost/type_traits/remove_pointer.hpp>

+

+#ifdef _MSC_VER

+#pragma warning(push)

+#pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored

+#endif

+

+namespace boost { namespace phoenix { namespace detail {

+

+ template <typename RT, typename MP>

+ struct member_variable

+ {

+ template <typename Sig>

+ struct result;

+

+ template <typename This, typename Class>

+ struct result<This(Class)>

+ : result<This(Class const &)>

+ {};

+

+ template <typename This, typename Class>

+ struct result<This(Class &)>

+ {

+ typedef typename boost::mpl::if_c<

+ boost::is_const<

+ typename boost::remove_pointer<

+ typename boost::remove_reference<Class>::type

+ >::type

+ >::value

+ , const RT&

+ , RT&

+ >::type

+ type;

+ };

+

+ member_variable(MP mp)

+ : mp(mp) {}

+

+ template <typename Class>

+ RT& operator()(Class& obj) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+

+ typedef typename proto::detail::class_member_traits<MP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*mp);

+ }

+

+ template <typename Class>

+ RT const& operator()(Class const& obj) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+

+ typedef typename proto::detail::class_member_traits<MP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*mp);

+ }

+

+ template <typename Class>

+ RT& operator()(Class* obj) const

+ {

+ return obj->*mp;

+ }

+

+ template <typename Class>

+ RT const& operator()(Class const* obj) const

+ {

+ return obj->*mp;

+ }

+

+ MP mp;

+ };

+}}}

+

+#ifdef _MSC_VER

+#pragma warning(pop)

+#endif

+

+#endif

+/*=============================================================================

+ Copyright (c) 2011 Hartmut Kaiser

+

+ 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)

+==============================================================================*/

+

+#if !defined(BOOST_PHOENIX_PREPROCESSED_BIND_DETAIL_FUNCTION_PTR_HPP)

+#define BOOST_PHOENIX_PREPROCESSED_BIND_DETAIL_FUNCTION_PTR_HPP

+

+#if BOOST_PHOENIX_LIMIT <= 10

+#include <boost/phoenix/bind/detail/preprocessed/function_ptr_10.hpp>

+#elif BOOST_PHOENIX_LIMIT <= 20

+#include <boost/phoenix/bind/detail/preprocessed/function_ptr_20.hpp>

+#elif BOOST_PHOENIX_LIMIT <= 30

+#include <boost/phoenix/bind/detail/preprocessed/function_ptr_30.hpp>

+#elif BOOST_PHOENIX_LIMIT <= 40

+#include <boost/phoenix/bind/detail/preprocessed/function_ptr_40.hpp>

+#elif BOOST_PHOENIX_LIMIT <= 50

+#include <boost/phoenix/bind/detail/preprocessed/function_ptr_50.hpp>

+#else

+#error "BOOST_PHOENIX_LIMIT out of bounds for preprocessed headers"

+#endif

+

+#endif

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<2, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1>

+ RT operator()(A0 & a0 , A1 & a1) const

+ {

+ return fp(a0 , a1);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<3, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2) const

+ {

+ return fp(a0 , a1 , a2);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<4, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const

+ {

+ return fp(a0 , a1 , a2 , a3);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<5, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<6, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<7, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<8, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<9, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<10, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);

+ }

+ FP fp;

+ };

+ };

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<2, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1>

+ RT operator()(A0 & a0 , A1 & a1) const

+ {

+ return fp(a0 , a1);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<3, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2) const

+ {

+ return fp(a0 , a1 , a2);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<4, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const

+ {

+ return fp(a0 , a1 , a2 , a3);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<5, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<6, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<7, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<8, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<9, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<10, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<11, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<12, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<13, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<14, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<15, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<16, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<17, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<18, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<19, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<20, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19);

+ }

+ FP fp;

+ };

+ };

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<2, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1>

+ RT operator()(A0 & a0 , A1 & a1) const

+ {

+ return fp(a0 , a1);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<3, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2) const

+ {

+ return fp(a0 , a1 , a2);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<4, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const

+ {

+ return fp(a0 , a1 , a2 , a3);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<5, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<6, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<7, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<8, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<9, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<10, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<11, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<12, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<13, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<14, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<15, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<16, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<17, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<18, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<19, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<20, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<21, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<22, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<23, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<24, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<25, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<26, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<27, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<28, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<29, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<30, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29);

+ }

+ FP fp;

+ };

+ };

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<2, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1>

+ RT operator()(A0 & a0 , A1 & a1) const

+ {

+ return fp(a0 , a1);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<3, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2) const

+ {

+ return fp(a0 , a1 , a2);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<4, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const

+ {

+ return fp(a0 , a1 , a2 , a3);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<5, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<6, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<7, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<8, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<9, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<10, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<11, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<12, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<13, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<14, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<15, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<16, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<17, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<18, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<19, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<20, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<21, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<22, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<23, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<24, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<25, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<26, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<27, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<28, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<29, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<30, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<31, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<32, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<33, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<34, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<35, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<36, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<37, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<38, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<39, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37 , typename A38>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37 , A38 & a38) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37 , a38);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<40, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37 , typename A38 , typename A39>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37 , A38 & a38 , A39 & a39) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37 , a38 , a39);

+ }

+ FP fp;

+ };

+ };

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<2, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1>

+ RT operator()(A0 & a0 , A1 & a1) const

+ {

+ return fp(a0 , a1);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<3, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2) const

+ {

+ return fp(a0 , a1 , a2);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<4, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const

+ {

+ return fp(a0 , a1 , a2 , a3);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<5, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<6, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<7, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<8, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<9, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<10, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<11, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<12, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<13, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<14, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<15, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<16, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<17, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<18, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<19, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<20, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<21, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<22, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<23, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<24, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<25, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<26, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<27, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<28, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<29, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<30, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<31, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<32, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<33, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<34, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<35, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<36, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<37, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<38, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<39, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37 , typename A38>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37 , A38 & a38) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37 , a38);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<40, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37 , typename A38 , typename A39>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37 , A38 & a38 , A39 & a39) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37 , a38 , a39);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<41, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37 , typename A38 , typename A39 , typename A40>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37 , A38 & a38 , A39 & a39 , A40 & a40) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37 , a38 , a39 , a40);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<42, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37 , typename A38 , typename A39 , typename A40 , typename A41>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37 , A38 & a38 , A39 & a39 , A40 & a40 , A41 & a41) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37 , a38 , a39 , a40 , a41);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<43, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37 , typename A38 , typename A39 , typename A40 , typename A41 , typename A42>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37 , A38 & a38 , A39 & a39 , A40 & a40 , A41 & a41 , A42 & a42) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37 , a38 , a39 , a40 , a41 , a42);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<44, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37 , typename A38 , typename A39 , typename A40 , typename A41 , typename A42 , typename A43>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37 , A38 & a38 , A39 & a39 , A40 & a40 , A41 & a41 , A42 & a42 , A43 & a43) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37 , a38 , a39 , a40 , a41 , a42 , a43);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<45, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37 , typename A38 , typename A39 , typename A40 , typename A41 , typename A42 , typename A43 , typename A44>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37 , A38 & a38 , A39 & a39 , A40 & a40 , A41 & a41 , A42 & a42 , A43 & a43 , A44 & a44) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37 , a38 , a39 , a40 , a41 , a42 , a43 , a44);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<46, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37 , typename A38 , typename A39 , typename A40 , typename A41 , typename A42 , typename A43 , typename A44 , typename A45>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37 , A38 & a38 , A39 & a39 , A40 & a40 , A41 & a41 , A42 & a42 , A43 & a43 , A44 & a44 , A45 & a45) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37 , a38 , a39 , a40 , a41 , a42 , a43 , a44 , a45);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<47, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37 , typename A38 , typename A39 , typename A40 , typename A41 , typename A42 , typename A43 , typename A44 , typename A45 , typename A46>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37 , A38 & a38 , A39 & a39 , A40 & a40 , A41 & a41 , A42 & a42 , A43 & a43 , A44 & a44 , A45 & a45 , A46 & a46) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37 , a38 , a39 , a40 , a41 , a42 , a43 , a44 , a45 , a46);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<48, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37 , typename A38 , typename A39 , typename A40 , typename A41 , typename A42 , typename A43 , typename A44 , typename A45 , typename A46 , typename A47>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37 , A38 & a38 , A39 & a39 , A40 & a40 , A41 & a41 , A42 & a42 , A43 & a43 , A44 & a44 , A45 & a45 , A46 & a46 , A47 & a47) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37 , a38 , a39 , a40 , a41 , a42 , a43 , a44 , a45 , a46 , a47);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<49, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37 , typename A38 , typename A39 , typename A40 , typename A41 , typename A42 , typename A43 , typename A44 , typename A45 , typename A46 , typename A47 , typename A48>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37 , A38 & a38 , A39 & a39 , A40 & a40 , A41 & a41 , A42 & a42 , A43 & a43 , A44 & a44 , A45 & a45 , A46 & a46 , A47 & a47 , A48 & a48) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37 , a38 , a39 , a40 , a41 , a42 , a43 , a44 , a45 , a46 , a47 , a48);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <typename Dummy>

+ struct function_ptr_impl<50, Dummy>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19 , typename A20 , typename A21 , typename A22 , typename A23 , typename A24 , typename A25 , typename A26 , typename A27 , typename A28 , typename A29 , typename A30 , typename A31 , typename A32 , typename A33 , typename A34 , typename A35 , typename A36 , typename A37 , typename A38 , typename A39 , typename A40 , typename A41 , typename A42 , typename A43 , typename A44 , typename A45 , typename A46 , typename A47 , typename A48 , typename A49>

+ RT operator()(A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19 , A20 & a20 , A21 & a21 , A22 & a22 , A23 & a23 , A24 & a24 , A25 & a25 , A26 & a26 , A27 & a27 , A28 & a28 , A29 & a29 , A30 & a30 , A31 & a31 , A32 & a32 , A33 & a33 , A34 & a34 , A35 & a35 , A36 & a36 , A37 & a37 , A38 & a38 , A39 & a39 , A40 & a40 , A41 & a41 , A42 & a42 , A43 & a43 , A44 & a44 , A45 & a45 , A46 & a46 , A47 & a47 , A48 & a48 , A49 & a49) const

+ {

+ return fp(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19 , a20 , a21 , a22 , a23 , a24 , a25 , a26 , a27 , a28 , a29 , a30 , a31 , a32 , a33 , a34 , a35 , a36 , a37 , a38 , a39 , a40 , a41 , a42 , a43 , a44 , a45 , a46 , a47 , a48 , a49);

+ }

+ FP fp;

+ };

+ };

+/*=============================================================================

+ Copyright (c) 2011 Hartmut Kaiser

+

+ 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)

+==============================================================================*/

+

+#if !defined(BOOST_PHOENIX_PREPROCESSED_BIND_DETAIL_MEMBER_FUNCTION_PTR_HPP)

+#define BOOST_PHOENIX_PREPROCESSED_BIND_DETAIL_MEMBER_FUNCTION_PTR_HPP

+

+#if BOOST_PHOENIX_LIMIT <= 10

+#include <boost/phoenix/bind/detail/preprocessed/member_function_ptr_10.hpp>

+#elif BOOST_PHOENIX_LIMIT <= 20

+#include <boost/phoenix/bind/detail/preprocessed/member_function_ptr_20.hpp>

+#elif BOOST_PHOENIX_LIMIT <= 30

+#include <boost/phoenix/bind/detail/preprocessed/member_function_ptr_30.hpp>

+#elif BOOST_PHOENIX_LIMIT <= 40

+#include <boost/phoenix/bind/detail/preprocessed/member_function_ptr_40.hpp>

+#elif BOOST_PHOENIX_LIMIT <= 50

+#include <boost/phoenix/bind/detail/preprocessed/member_function_ptr_50.hpp>

+#else

+#error "BOOST_PHOENIX_LIMIT out of bounds for preprocessed headers"

+#endif

+

+#endif

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<1>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0>

+ RT operator()(Class& obj, A0 & a0) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0);

+ }

+ template <typename Class, typename A0>

+ RT operator()(Class* obj, A0 & a0) const

+ {

+ return (obj->*fp)(a0);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<2>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1);

+ }

+ template <typename Class, typename A0 , typename A1>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1) const

+ {

+ return (obj->*fp)(a0 , a1);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<3>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2) const

+ {

+ return (obj->*fp)(a0 , a1 , a2);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<4>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<5>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<6>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<7>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<8>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<9>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<10>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);

+ }

+ FP fp;

+ };

+ };

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<1>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0>

+ RT operator()(Class& obj, A0 & a0) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0);

+ }

+ template <typename Class, typename A0>

+ RT operator()(Class* obj, A0 & a0) const

+ {

+ return (obj->*fp)(a0);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<2>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1);

+ }

+ template <typename Class, typename A0 , typename A1>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1) const

+ {

+ return (obj->*fp)(a0 , a1);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<3>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2) const

+ {

+ return (obj->*fp)(a0 , a1 , a2);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<4>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<5>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<6>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<7>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<8>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<9>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<10>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<11>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<12>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<13>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<14>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<15>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<16>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<17>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<18>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<19>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<20>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18 , typename A19>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5 , A6 & a6 , A7 & a7 , A8 & a8 , A9 & a9 , A10 & a10 , A11 & a11 , A12 & a12 , A13 & a13 , A14 & a14 , A15 & a15 , A16 & a16 , A17 & a17 , A18 & a18 , A19 & a19) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19);

+ }

+ FP fp;

+ };

+ };

+/*=============================================================================

+ Copyright (c) 2001-2007 Joel de Guzman

+

+ 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)

+==============================================================================*/

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<1>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0>

+ RT operator()(Class& obj, A0 & a0) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0);

+ }

+ template <typename Class, typename A0>

+ RT operator()(Class* obj, A0 & a0) const

+ {

+ return (obj->*fp)(a0);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<2>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1);

+ }

+ template <typename Class, typename A0 , typename A1>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1) const

+ {

+ return (obj->*fp)(a0 , a1);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<3>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2) const

+ {

+ return (obj->*fp)(a0 , a1 , a2);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<4>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<5>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4);

+ }

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>

+ RT operator()(Class* obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4) const

+ {

+ return (obj->*fp)(a0 , a1 , a2 , a3 , a4);

+ }

+ FP fp;

+ };

+ };

+

+

+

+

+

+

+

+ template <>

+ struct member_function_ptr_impl<6>

+ {

+ template <typename RT, typename FP>

+ struct impl

+ {

+ typedef RT result_type;

+ impl(FP fp)

+ : fp(fp) {}

+ template <typename Class, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>

+ RT operator()(Class& obj, A0 & a0 , A1 & a1 , A2 & a2 , A3 & a3 , A4 & a4 , A5 & a5) const

+ {

+ BOOST_PROTO_USE_GET_POINTER();

+ typedef typename proto::detail::class_member_traits<FP>::class_type class_type;

+ return (BOOST_PROTO_GET_POINTER(class_type, obj)->*fp)(a0 , a1 , a2 , a3 , a4 , a5);

+ }