// Boost Lambda Library -- member_ptr.hpp --------------------- // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) // Copyright (C) 2000 Gary Powell (gary.powell@sierra.com) // // 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) // // For more information, see www.boost.org // -------------------------------------------------------------------------- #if !defined(BOOST_LAMBDA_MEMBER_PTR_HPP) #define BOOST_LAMBDA_MEMBER_PTR_HPP namespace boost { namespace lambda { class member_pointer_action {}; namespace detail { // the boost type_traits member_pointer traits are not enough, // need to know more details. template<class T> struct member_pointer { typedef typename boost::add_reference<T>::type type; typedef detail::unspecified class_type; typedef detail::unspecified qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = false); }; template<class T, class U> struct member_pointer<T U::*> { typedef typename boost::add_reference<T>::type type; typedef U class_type; typedef U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = true); BOOST_STATIC_CONSTANT(bool, is_function_member = false); }; template<class T, class U> struct member_pointer<const T U::*> { typedef typename boost::add_reference<const T>::type type; typedef U class_type; typedef const U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = true); BOOST_STATIC_CONSTANT(bool, is_function_member = false); }; template<class T, class U> struct member_pointer<volatile T U::*> { typedef typename boost::add_reference<volatile T>::type type; typedef U class_type; typedef volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = true); BOOST_STATIC_CONSTANT(bool, is_function_member = false); }; template<class T, class U> struct member_pointer<const volatile T U::*> { typedef typename boost::add_reference<const volatile T>::type type; typedef U class_type; typedef const volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = true); BOOST_STATIC_CONSTANT(bool, is_function_member = false); }; // -- nonconst member functions -- template<class T, class U> struct member_pointer<T (U::*)()> { typedef T type; typedef U class_type; typedef U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1> struct member_pointer<T (U::*)(A1)> { typedef T type; typedef U class_type; typedef U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2> struct member_pointer<T (U::*)(A1, A2)> { typedef T type; typedef U class_type; typedef U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3> struct member_pointer<T (U::*)(A1, A2, A3)> { typedef T type; typedef U class_type; typedef U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4> struct member_pointer<T (U::*)(A1, A2, A3, A4)> { typedef T type; typedef U class_type; typedef U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5)> { typedef T type; typedef U class_type; typedef U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6)> { typedef T type; typedef U class_type; typedef U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7)> { typedef T type; typedef U class_type; typedef U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8)> { typedef T type; typedef U class_type; typedef U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)> { typedef T type; typedef U class_type; typedef U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; // -- const member functions -- template<class T, class U> struct member_pointer<T (U::*)() const> { typedef T type; typedef U class_type; typedef const U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1> struct member_pointer<T (U::*)(A1) const> { typedef T type; typedef U class_type; typedef const U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2> struct member_pointer<T (U::*)(A1, A2) const> { typedef T type; typedef U class_type; typedef const U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3> struct member_pointer<T (U::*)(A1, A2, A3) const> { typedef T type; typedef U class_type; typedef const U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4> struct member_pointer<T (U::*)(A1, A2, A3, A4) const> { typedef T type; typedef U class_type; typedef const U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5) const> { typedef T type; typedef U class_type; typedef const U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) const> { typedef T type; typedef U class_type; typedef const U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) const> { typedef T type; typedef U class_type; typedef const U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8) const> { typedef T type; typedef U class_type; typedef const U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const> { typedef T type; typedef U class_type; typedef const U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; // -- volatile -- template<class T, class U> struct member_pointer<T (U::*)() volatile> { typedef T type; typedef U class_type; typedef volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1> struct member_pointer<T (U::*)(A1) volatile> { typedef T type; typedef U class_type; typedef volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2> struct member_pointer<T (U::*)(A1, A2) volatile> { typedef T type; typedef U class_type; typedef volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3> struct member_pointer<T (U::*)(A1, A2, A3) volatile> { typedef T type; typedef U class_type; typedef volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4> struct member_pointer<T (U::*)(A1, A2, A3, A4) volatile> { typedef T type; typedef U class_type; typedef volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5) volatile> { typedef T type; typedef U class_type; typedef volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) volatile> { typedef T type; typedef U class_type; typedef volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) volatile> { typedef T type; typedef U class_type; typedef volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8) volatile> { typedef T type; typedef U class_type; typedef volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) volatile> { typedef T type; typedef U class_type; typedef volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; // -- const volatile template<class T, class U> struct member_pointer<T (U::*)() const volatile> { typedef T type; typedef U class_type; typedef const volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1> struct member_pointer<T (U::*)(A1) const volatile> { typedef T type; typedef U class_type; typedef const volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2> struct member_pointer<T (U::*)(A1, A2) const volatile> { typedef T type; typedef U class_type; typedef const volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3> struct member_pointer<T (U::*)(A1, A2, A3) const volatile> { typedef T type; typedef U class_type; typedef const volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4> struct member_pointer<T (U::*)(A1, A2, A3, A4) const volatile> { typedef T type; typedef U class_type; typedef const volatile U qualified_class_type; }; template<class T, class U, class A1, class A2, class A3, class A4, class A5> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5) const volatile> { typedef T type; typedef U class_type; typedef const volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6) const volatile> { typedef T type; typedef U class_type; typedef const volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7) const volatile> { typedef T type; typedef U class_type; typedef const volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8) const volatile> { typedef T type; typedef U class_type; typedef const volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; template<class T, class U, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct member_pointer<T (U::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const volatile> { typedef T type; typedef U class_type; typedef const volatile U qualified_class_type; BOOST_STATIC_CONSTANT(bool, is_data_member = false); BOOST_STATIC_CONSTANT(bool, is_function_member = true); }; } // detail namespace detail { // this class holds a pointer to a member function and the object. // when called, it just calls the member function with the parameters // provided // It would have been possible to use existing lambda_functors to represent // a bound member function like this, but to have a separate template is // safer, since now this functor doesn't mix and match with lambda_functors // only thing you can do with this is to call it // note that previously instantiated classes // (other_action<member_pointer_action> and member_pointer_action_helper // guarantee, that A and B are // such types, that for objects a and b of corresponding types, a->*b leads // to the builtin ->* to be called. So types that would end in a call to // a user defined ->* do not create a member_pointer_caller object. template<class RET, class A, class B> class member_pointer_caller { A a; B b; public: member_pointer_caller(const A& aa, const B& bb) : a(aa), b(bb) {} RET operator()() const { return (a->*b)(); } template<class A1> RET operator()(const A1& a1) const { return (a->*b)(a1); } template<class A1, class A2> RET operator()(const A1& a1, const A2& a2) const { return (a->*b)(a1, a2); } template<class A1, class A2, class A3> RET operator()(const A1& a1, const A2& a2, const A3& a3) const { return (a->*b)(a1, a2, a3); } template<class A1, class A2, class A3, class A4> RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return (a->*b)(a1, a2, a3, a4); } template<class A1, class A2, class A3, class A4, class A5> RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return (a->*b)(a1, a2, a3, a4, a5); } template<class A1, class A2, class A3, class A4, class A5, class A6> RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6) const { return (a->*b)(a1, a2, a3, a4, a5, a6); } template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7) const { return (a->*b)(a1, a2, a3, a4, a5, a6, a7); } template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8) const { return (a->*b)(a1, a2, a3, a4, a5, a6, a7, a8); } template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> RET operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9) const { return (a->*b)(a1, a2, a3, a4, a5, a6, a7, a8, a9); } }; // helper templates for return type deduction and action classes // different cases for data member, function member, neither // true-true case template <bool Is_data_member, bool Is_function_member> struct member_pointer_action_helper; // cannot be both, no body provided // data member case // this means, that B is a data member and A is a pointer type, // so either built-in ->* should be called, or there is an error template <> struct member_pointer_action_helper<true, false> { public: template<class RET, class A, class B> static RET apply(A& a, B& b) { return a->*b; } template<class A, class B> struct return_type { private: typedef typename detail::remove_reference_and_cv<B>::type plainB; typedef typename detail::member_pointer<plainB>::type type0; // we remove the reference now, as we may have to add cv:s typedef typename boost::remove_reference<type0>::type type1; // A is a reference to pointer // remove the top level cv qualifiers and reference typedef typename detail::remove_reference_and_cv<A>::type non_ref_A; // A is a pointer type, so take the type pointed to typedef typename ::boost::remove_pointer<non_ref_A>::type non_pointer_A; public: // For non-reference types, we must add const and/or volatile if // the pointer type has these qualifiers // If the member is a reference, these do not have any effect // (cv T == T if T is a reference type) typedef typename detail::IF< ::boost::is_const<non_pointer_A>::value, typename ::boost::add_const<type1>::type, type1 >::RET type2; typedef typename detail::IF< ::boost::is_volatile<non_pointer_A>::value, typename ::boost::add_volatile<type2>::type, type2 >::RET type3; // add reference back typedef typename ::boost::add_reference<type3>::type type; }; }; // neither case template <> struct member_pointer_action_helper<false, false> { public: template<class RET, class A, class B> static RET apply(A& a, B& b) { // not a built in member pointer operator, just call ->* return a->*b; } // an overloaded member pointer operators, user should have specified // the return type // At this point we know that there is no matching specialization for // return_type_2, so try return_type_2_plain template<class A, class B> struct return_type { typedef typename plain_return_type_2< other_action<member_pointer_action>, A, B >::type type; }; }; // member pointer function case // This is a built in ->* call for a member function, // the only thing that you can do with that, is to give it some arguments // note, it is guaranteed that A is a pointer type, and thus it cannot // be a call to overloaded ->* template <> struct member_pointer_action_helper<false, true> { public: template<class RET, class A, class B> static RET apply(A& a, B& b) { typedef typename ::boost::remove_cv<B>::type plainB; typedef typename detail::member_pointer<plainB>::type ret_t; typedef typename ::boost::remove_cv<A>::type plainA; // we always strip cv:s to // make the two routes (calling and type deduction) // to give the same results (and the const does not make any functional // difference) return detail::member_pointer_caller<ret_t, plainA, plainB>(a, b); } template<class A, class B> struct return_type { typedef typename detail::remove_reference_and_cv<B>::type plainB; typedef typename detail::member_pointer<plainB>::type ret_t; typedef typename detail::remove_reference_and_cv<A>::type plainA; typedef detail::member_pointer_caller<ret_t, plainA, plainB> type; }; }; } // detail template<> class other_action<member_pointer_action> { public: template<class RET, class A, class B> static RET apply(A& a, B& b) { typedef typename ::boost::remove_cv<B>::type plainB; return detail::member_pointer_action_helper< boost::is_pointer<A>::value && detail::member_pointer<plainB>::is_data_member, boost::is_pointer<A>::value && detail::member_pointer<plainB>::is_function_member >::template apply<RET>(a, b); } }; // return type deduction -- // If the right argument is a pointer to data member, // and the left argument is of compatible pointer to class type // return type is a reference to the data member type // if right argument is a pointer to a member function, and the left // argument is of a compatible type, the return type is a // member_pointer_caller (see above) // Otherwise, return type deduction fails. There is either an error, // or the user is trying to call an overloaded ->* // In such a case either ret<> must be used, or a return_type_2 user // defined specialization must be provided template<class A, class B> struct return_type_2<other_action<member_pointer_action>, A, B> { private: typedef typename detail::remove_reference_and_cv<B>::type plainB; public: typedef typename detail::member_pointer_action_helper< detail::member_pointer<plainB>::is_data_member, detail::member_pointer<plainB>::is_function_member >::template return_type<A, B>::type type; }; // this is the way the generic lambda_functor_base functions instantiate // return type deduction. We turn it into return_type_2, so that the // user can provide specializations on that level. template<class Args> struct return_type_N<other_action<member_pointer_action>, Args> { typedef typename boost::tuples::element<0, Args>::type A; typedef typename boost::tuples::element<1, Args>::type B; typedef typename return_type_2<other_action<member_pointer_action>, typename boost::remove_reference<A>::type, typename boost::remove_reference<B>::type >::type type; }; template<class Arg1, class Arg2> inline const lambda_functor< lambda_functor_base< action<2, other_action<member_pointer_action> >, tuple<lambda_functor<Arg1>, typename const_copy_argument<Arg2>::type> > > operator->*(const lambda_functor<Arg1>& a1, const Arg2& a2) { return lambda_functor_base< action<2, other_action<member_pointer_action> >, tuple<lambda_functor<Arg1>, typename const_copy_argument<Arg2>::type> > (tuple<lambda_functor<Arg1>, typename const_copy_argument<Arg2>::type>(a1, a2)); } template<class Arg1, class Arg2> inline const lambda_functor< lambda_functor_base< action<2, other_action<member_pointer_action> >, tuple<lambda_functor<Arg1>, lambda_functor<Arg2> > > > operator->*(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) { return lambda_functor_base< action<2, other_action<member_pointer_action> >, tuple<lambda_functor<Arg1>, lambda_functor<Arg2> > > (tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2)); } template<class Arg1, class Arg2> inline const lambda_functor< lambda_functor_base< action<2, other_action<member_pointer_action> >, tuple<typename const_copy_argument<Arg1>::type, lambda_functor<Arg2> > > > operator->*(const Arg1& a1, const lambda_functor<Arg2>& a2) { return lambda_functor_base< action<2, other_action<member_pointer_action> >, tuple<typename const_copy_argument<Arg1>::type, lambda_functor<Arg2> > > (tuple<typename const_copy_argument<Arg1>::type, lambda_functor<Arg2> >(a1, a2)); } } // namespace lambda } // namespace boost #endif