// Boost Lambda Library -- member_ptr.hpp ---------------------

 // Copyright (C) 1999, 2000 Jaakko Järvi (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