williamr@2: // Boost Lambda Library -  function_adaptors.hpp ----------------------------
williamr@2:  
williamr@2: // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
williamr@2: //
williamr@2: // Distributed under the Boost Software License, Version 1.0. (See
williamr@2: // accompanying file LICENSE_1_0.txt or copy at
williamr@2: // http://www.boost.org/LICENSE_1_0.txt)
williamr@2: //
williamr@2: // For more information, see www.boost.org
williamr@2: 
williamr@2: 
williamr@2: #ifndef BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
williamr@2: #define BOOST_LAMBDA_FUNCTION_ADAPTORS_HPP
williamr@2: 
williamr@2: #include "boost/type_traits/same_traits.hpp"
williamr@2: 
williamr@2: namespace boost { 
williamr@2: namespace lambda {
williamr@2: 
williamr@2: template <class Func> struct function_adaptor {
williamr@2: 
williamr@2:   // we do not know the return type off-hand, we must ask it from Func
williamr@2:   template <class Args> class sig { 
williamr@2:     typedef typename Args::head_type F; 
williamr@2:     typedef typename detail::remove_reference_and_cv<Func>::type plainF;
williamr@2:   public:
williamr@2:     // To sig we pass a cons list, where the head is the function object type
williamr@2:     // itself (potentially cv-qualified)
williamr@2:     // and the tail contains the types of the actual arguments to be passed
williamr@2:     // to the function object. The arguments can be cv qualified
williamr@2:     // as well.
williamr@2:     typedef typename plainF::template sig<Args>::type type;
williamr@2:   };
williamr@2: 
williamr@2:   template<class RET, class A1>
williamr@2:   static RET apply(A1& a1) {
williamr@2:     return a1();
williamr@2:   }
williamr@2:   template<class RET, class A1, class A2>
williamr@2:   static RET apply(A1& a1, A2& a2) {
williamr@2:     return a1(a2);
williamr@2:   }
williamr@2:   template<class RET, class A1, class A2, class A3>
williamr@2:   static RET apply(A1& a1, A2& a2, A3& a3) {
williamr@2:     return a1(a2, a3);
williamr@2:   }
williamr@2:   template<class RET, class A1, class A2, class A3, class A4>
williamr@2:   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2:     return a1(a2, a3, a4);
williamr@2:   }
williamr@2:   template<class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2:   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
williamr@2:     return a1(a2, a3, a4, a5);
williamr@2:   }
williamr@2:   template<class RET, class A1, class A2, class A3, class A4, class A5, class A6>
williamr@2:   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
williamr@2:     return a1(a2, a3, a4, a5, a6);
williamr@2:   }
williamr@2:   template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
williamr@2:            class A7>
williamr@2:   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
williamr@2:                            A7& a7) {
williamr@2:     return a1(a2, a3, a4, a5, a6, a7);
williamr@2:   }
williamr@2:   template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
williamr@2:            class A7, class A8>
williamr@2:   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
williamr@2:                            A7& a7, A8& a8) {
williamr@2:     return a1(a2, a3, a4, a5, a6, a7, a8);
williamr@2:   }
williamr@2:   template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
williamr@2:            class A7, class A8, class A9>
williamr@2:   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
williamr@2:                            A7& a7, A8& a8, A9& a9) {
williamr@2:     return a1(a2, a3, a4, a5, a6, a7, a8, a9);
williamr@2:   }
williamr@2:   template<class RET, class A1, class A2, class A3, class A4, class A5, class A6, 
williamr@2:            class A7, class A8, class A9, class A10>
williamr@2:   static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, 
williamr@2:                            A7& a7, A8& a8, A9& a9, A10& a10) {
williamr@2:     return a1(a2, a3, a4, a5, a6, a7, a8, a9, a10);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Func> struct function_adaptor<const Func>; // error 
williamr@2: 
williamr@2: // -- function adaptors with data member access
williamr@2: template <class Object, class T>
williamr@2: struct function_adaptor<T Object::*> {
williamr@2: 
williamr@2:   //  typedef detail::unspecified type;
williamr@2: 
williamr@2:   // T can have qualifiers and can be a reference type
williamr@2:   // We get the return type by adding const, if the object through which
williamr@2:   // the data member is accessed is const, and finally adding a reference
williamr@2:   template<class Args> class sig { 
williamr@2:     typedef typename boost::tuples::element<1, Args>::type argument_type;
williamr@2: 
williamr@2:     typedef typename detail::IF<boost::is_const<argument_type>::value,
williamr@2:       typename boost::add_const<T>::type,
williamr@2:       T
williamr@2:     >::RET properly_consted_return_type;
williamr@2: 
williamr@2:     typedef typename detail::IF<
williamr@2:         boost::is_volatile<properly_consted_return_type>::value,
williamr@2:       typename boost::add_volatile<properly_consted_return_type>::type,
williamr@2:       properly_consted_return_type
williamr@2:     >::RET properly_cvd_return_type;
williamr@2: 
williamr@2: 
williamr@2:   public:
williamr@2:     typedef typename 
williamr@2:       boost::add_reference<properly_cvd_return_type>::type type;
williamr@2:   };
williamr@2: 
williamr@2:   template <class RET>
williamr@2:   static RET apply( T Object::*data, Object& o) {
williamr@2:     return o.*data;
williamr@2:   }
williamr@2:   template <class RET>
williamr@2:   static RET apply( T Object::*data, const Object& o) {
williamr@2:     return o.*data;
williamr@2:   }
williamr@2:   template <class RET>
williamr@2:   static RET apply( T Object::*data, volatile Object& o) {
williamr@2:     return o.*data;
williamr@2:   }
williamr@2:   template <class RET>
williamr@2:   static RET apply( T Object::*data, const volatile Object& o) {
williamr@2:     return o.*data;
williamr@2:   }
williamr@2:   template <class RET>
williamr@2:   static RET apply( T Object::*data, Object* o) {
williamr@2:     return o->*data;
williamr@2:   }
williamr@2:   template <class RET>
williamr@2:   static RET apply( T Object::*data, const Object* o) {
williamr@2:     return o->*data;
williamr@2:   }
williamr@2:   template <class RET>
williamr@2:   static RET apply( T Object::*data, volatile Object* o) {
williamr@2:     return o->*data;
williamr@2:   }
williamr@2:   template <class RET>
williamr@2:   static RET apply( T Object::*data, const volatile Object* o) {
williamr@2:     return o->*data;
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: // -- function adaptors with 1 argument apply
williamr@2:    
williamr@2: template <class Result>
williamr@2: struct function_adaptor<Result (void)> {
williamr@2:   
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET>
williamr@2:   static Result apply(Result (*func)()) {
williamr@2:     return func();
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Result>
williamr@2: struct function_adaptor<Result (*)(void)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET>
williamr@2:   static Result apply(Result (*func)()) {
williamr@2:     return func();
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: 
williamr@2: // -- function adaptors with 2 argument apply
williamr@2: template <class Object, class Result>
williamr@2: struct function_adaptor<Result (Object::*)() const> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET>
williamr@2:   static Result apply( Result (Object::*func)() const, const Object* o) {
williamr@2:     return (o->*func)();
williamr@2:   }
williamr@2:   template <class RET>
williamr@2:   static Result apply( Result (Object::*func)() const, const Object& o) {
williamr@2:     return (o.*func)();
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Object, class Result>
williamr@2: struct function_adaptor<Result (Object::*)()> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET>
williamr@2:   static Result apply( Result (Object::*func)(), Object* o) {
williamr@2:     return (o->*func)();
williamr@2:   }
williamr@2:   template <class RET>
williamr@2:   static Result apply( Result (Object::*func)(), Object& o) {
williamr@2:     return (o.*func)();
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Result>
williamr@2: struct function_adaptor<Result (Arg1)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1>
williamr@2:   static Result apply(Result (*func)(Arg1), A1& a1) {
williamr@2:     return func(a1);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Result>
williamr@2: struct function_adaptor<Result (*)(Arg1)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1>
williamr@2:   static Result apply(Result (*func)(Arg1), A1& a1) {
williamr@2:     return func(a1);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: 
williamr@2: // -- function adaptors with 3 argument apply
williamr@2: template <class Object, class Arg1, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1) const> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1>
williamr@2:   static Result apply( Result (Object::*func)(Arg1) const, const Object* o, 
williamr@2:     A1& a1) {
williamr@2:     return (o->*func)(a1);
williamr@2:   }
williamr@2:   template <class RET, class A1>
williamr@2:   static Result apply( Result (Object::*func)(Arg1) const, const Object& o, 
williamr@2:     A1& a1) {
williamr@2:     return (o.*func)(a1);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Object, class Arg1, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1>
williamr@2:   static Result apply( Result (Object::*func)(Arg1), Object* o, A1& a1) {
williamr@2:     return (o->*func)(a1);
williamr@2:   }
williamr@2:   template <class RET, class A1>
williamr@2:   static Result apply( Result (Object::*func)(Arg1), Object& o, A1& a1) {
williamr@2:     return (o.*func)(a1);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Result>
williamr@2: struct function_adaptor<Result (Arg1, Arg2)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {
williamr@2:     return func(a1, a2);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Result>
williamr@2: struct function_adaptor<Result (*)(Arg1, Arg2)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2), A1& a1, A2& a2) {
williamr@2:     return func(a1, a2);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: 
williamr@2: // -- function adaptors with 4 argument apply
williamr@2: template <class Object, class Arg1, class Arg2, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1, Arg2) const> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object* o, A1& a1, A2& a2) {
williamr@2:     return (o->*func)(a1, a2);
williamr@2:   }
williamr@2:   template <class RET, class A1, class A2>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2) const, const Object& o, A1& a1, A2& a2) {
williamr@2:     return (o.*func)(a1, a2);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Object, class Arg1, class Arg2, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1, Arg2)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2), Object* o, A1& a1, A2& a2) {
williamr@2:     return (o->*func)(a1, a2);
williamr@2:   }
williamr@2:   template <class RET, class A1, class A2>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2), Object& o, A1& a1, A2& a2) {
williamr@2:     return (o.*func)(a1, a2);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Arg3, class Result>
williamr@2: struct function_adaptor<Result (Arg1, Arg2, Arg3)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {
williamr@2:     return func(a1, a2, a3);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Arg3, class Result>
williamr@2: struct function_adaptor<Result (*)(Arg1, Arg2, Arg3)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2, Arg3), A1& a1, A2& a2, A3& a3) {
williamr@2:     return func(a1, a2, a3);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: 
williamr@2: // -- function adaptors with 5 argument apply
williamr@2: template <class Object, class Arg1, class Arg2, class Arg3, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3) const> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object* o, A1& a1, A2& a2, A3& a3) {
williamr@2:     return (o->*func)(a1, a2, a3);
williamr@2:   }
williamr@2:   template <class RET, class A1, class A2, class A3>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3) const, const Object& o, A1& a1, A2& a2, A3& a3) {
williamr@2:     return (o.*func)(a1, a2, a3);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Object, class Arg1, class Arg2, class Arg3, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object* o, A1& a1, A2& a2, A3& a3) {
williamr@2:     return (o->*func)(a1, a2, a3);
williamr@2:   }
williamr@2:   template <class RET, class A1, class A2, class A3>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3), Object& o, A1& a1, A2& a2, A3& a3) {
williamr@2:     return (o.*func)(a1, a2, a3);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
williamr@2: struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2:     return func(a1, a2, a3, a4);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Arg3, class Arg4, class Result>
williamr@2: struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4), A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2:     return func(a1, a2, a3, a4);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: 
williamr@2: // -- function adaptors with 6 argument apply
williamr@2: template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4) const> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2:     return (o->*func)(a1, a2, a3, a4);
williamr@2:   }
williamr@2:   template <class RET, class A1, class A2, class A3, class A4>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2:     return (o.*func)(a1, a2, a3, a4);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object* o, A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2:     return (o->*func)(a1, a2, a3, a4);
williamr@2:   }
williamr@2:   template <class RET, class A1, class A2, class A3, class A4>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4), Object& o, A1& a1, A2& a2, A3& a3, A4& a4) {
williamr@2:     return (o.*func)(a1, a2, a3, a4);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
williamr@2: struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
williamr@2:     return func(a1, a2, a3, a4, a5);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
williamr@2: struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
williamr@2:     return func(a1, a2, a3, a4, a5);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: 
williamr@2: // -- function adaptors with 7 argument apply
williamr@2: template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5) const> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
williamr@2:     return (o->*func)(a1, a2, a3, a4, a5);
williamr@2:   }
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
williamr@2:     return (o.*func)(a1, a2, a3, a4, a5);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
williamr@2:     return (o->*func)(a1, a2, a3, a4, a5);
williamr@2:   }
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
williamr@2:     return (o.*func)(a1, a2, a3, a4, a5);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
williamr@2: struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
williamr@2:     return func(a1, a2, a3, a4, a5, a6);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
williamr@2: struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
williamr@2:     return func(a1, a2, a3, a4, a5, a6);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: 
williamr@2: // -- function adaptors with 8 argument apply
williamr@2: template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
williamr@2:     return (o->*func)(a1, a2, a3, a4, a5, a6);
williamr@2:   }
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
williamr@2:     return (o.*func)(a1, a2, a3, a4, a5, a6);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
williamr@2:     return (o->*func)(a1, a2, a3, a4, a5, a6);
williamr@2:   }
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
williamr@2:     return (o.*func)(a1, a2, a3, a4, a5, a6);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
williamr@2: struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
williamr@2:     return func(a1, a2, a3, a4, a5, a6, a7);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
williamr@2: struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
williamr@2:     return func(a1, a2, a3, a4, a5, a6, a7);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: 
williamr@2: // -- function adaptors with 9 argument apply
williamr@2: template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
williamr@2:     return (o->*func)(a1, a2, a3, a4, a5, a6, a7);
williamr@2:   }
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
williamr@2:     return (o.*func)(a1, a2, a3, a4, a5, a6, a7);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
williamr@2:     return (o->*func)(a1, a2, a3, a4, a5, a6, a7);
williamr@2:   }
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
williamr@2:     return (o.*func)(a1, a2, a3, a4, a5, a6, a7);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
williamr@2: struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
williamr@2:     return func(a1, a2, a3, a4, a5, a6, a7, a8);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
williamr@2: struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
williamr@2:     return func(a1, a2, a3, a4, a5, a6, a7, a8);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: 
williamr@2: // -- function adaptors with 10 argument apply
williamr@2: template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const, const Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
williamr@2:     return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8);
williamr@2:   }
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) const, const Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
williamr@2:     return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Object, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Result>
williamr@2: struct function_adaptor<Result (Object::*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), Object* o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
williamr@2:     return (o->*func)(a1, a2, a3, a4, a5, a6, a7, a8);
williamr@2:   }
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
williamr@2:   static Result apply( Result (Object::*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8), Object& o, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) {
williamr@2:     return (o.*func)(a1, a2, a3, a4, a5, a6, a7, a8);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
williamr@2: struct function_adaptor<Result (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) {
williamr@2:     return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: template <class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9, class Result>
williamr@2: struct function_adaptor<Result (*)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> {
williamr@2: 
williamr@2:   template<class T> struct sig { typedef Result type; };
williamr@2:   template <class RET, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
williamr@2:   static Result apply(Result (*func)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9), A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) {
williamr@2:     return func(a1, a2, a3, a4, a5, a6, a7, a8, a9);
williamr@2:   }
williamr@2: };
williamr@2: 
williamr@2: } // namespace lambda
williamr@2: } // namespace boost
williamr@2: 
williamr@2: #endif
williamr@2: 
williamr@2: 
williamr@2: 
williamr@2: 
williamr@2: 
williamr@2: 
williamr@2: 
williamr@2: 
williamr@2: 
williamr@2: 
williamr@2: 
williamr@2: 
williamr@2: