Chris@16: /*=============================================================================
Chris@16:     Phoenix v1.2
Chris@16:     Copyright (c) 2001-2002 Joel de Guzman
Chris@16: 
Chris@16:   Distributed under the Boost Software License, Version 1.0. (See accompanying
Chris@16:   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16: ==============================================================================*/
Chris@16: #ifndef PHOENIX_BINDERS_HPP
Chris@16: #define PHOENIX_BINDERS_HPP
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: #include <boost/spirit/home/classic/phoenix/functions.hpp>
Chris@16: #include <boost/type_traits/is_const.hpp>
Chris@16: #include <boost/mpl/if.hpp>
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: namespace phoenix {
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Binders
Chris@16: //
Chris@16: //      There are times when it is desireable to bind a simple functor,
Chris@16: //      function, member function or member variable for deferred
Chris@16: //      evaluation. This can be done through the binding facilities
Chris@16: //      provided below. There are template classes:
Chris@16: //
Chris@16: //          1) function_ptr           ( function pointer binder )
Chris@16: //          2) functor                ( functor pointer binder )
Chris@16: //          3) member_function_ptr    ( member function pointer binder )
Chris@16: //          4) member_var_ptr         ( member variable pointer binder )
Chris@16: //
Chris@16: //      These template classes are specialized lazy function classes for
Chris@16: //      functors, function pointers, member function pointers and member
Chris@16: //      variable pointers, respectively. These are subclasses of the
Chris@16: //      lazy-function class (see functions.hpp). Each of these has a
Chris@16: //      corresponding overloaded bind(x) function. Each bind(x) function
Chris@16: //      generates a suitable binder object.
Chris@16: //
Chris@16: //      Example, given a function foo:
Chris@16: //
Chris@16: //          void foo_(int n) { std::cout << n << std::endl; }
Chris@16: //
Chris@16: //      Here's how the function foo is bound:
Chris@16: //
Chris@16: //          bind(&foo_)
Chris@16: //
Chris@16: //      This bind expression results to a lazy-function (see
Chris@16: //      functions.hpp) that is lazily evaluated. This bind expression is
Chris@16: //      also equivalent to:
Chris@16: //
Chris@16: //          function_ptr<void, int> foo = &foo_;
Chris@16: //
Chris@16: //      The template parameter of the function_ptr is the return and
Chris@16: //      argument types of actual signature of the function to be bound
Chris@16: //      read from left to right:
Chris@16: //
Chris@16: //          void foo_(int); ---> function_ptr<void, int>
Chris@16: //
Chris@16: //      Either bind(&foo_) and its equivalent foo can now be used in the
Chris@16: //      same way a lazy function (see functions.hpp) is used:
Chris@16: //
Chris@16: //          bind(&foo_)(arg1)
Chris@16: //
Chris@16: //      or
Chris@16: //
Chris@16: //          foo(arg1)
Chris@16: //
Chris@16: //      The latter, of course, being much easier to understand. This is
Chris@16: //      now a full-fledged lazy function that can finally be evaluated
Chris@16: //      by another function call invocation. A second function call will
Chris@16: //      invoke the actual foo function:
Chris@16: //
Chris@16: //          int i = 4;
Chris@16: //          foo(arg1)(i);
Chris@16: //
Chris@16: //      will print out "4".
Chris@16: //
Chris@16: //      Binding functors and member functions can be done similarly.
Chris@16: //      Here's how to bind a functor (e.g. std::plus<int>):
Chris@16: //
Chris@16: //          bind(std::plus<int>())
Chris@16: //
Chris@16: //      or
Chris@16: //
Chris@16: //          functor<std::plus<int> > plus;
Chris@16: //
Chris@16: //      Again, these are full-fledged lazy functions. In this case,
Chris@16: //      unlike the first example, expect 2 arguments (std::plus<int>
Chris@16: //      needs two arguments lhs and rhs). Either or both of which can be
Chris@16: //      lazily bound:
Chris@16: //
Chris@16: //          plus(arg1, arg2)     // arg1 + arg2
Chris@16: //          plus(100, arg1)      // 100 + arg1
Chris@16: //          plus(100, 200)       // 300
Chris@16: //
Chris@16: //      A bound member function takes in a pointer or reference to an
Chris@16: //      object as the first argument. For instance, given:
Chris@16: //
Chris@16: //          struct xyz { void foo(int) const; };
Chris@16: //
Chris@16: //      xyz's foo member function can be bound as:
Chris@16: //
Chris@16: //          bind(&xyz::foo)
Chris@16: //
Chris@16: //      or
Chris@16: //
Chris@16: //          member_function_ptr<void, xyz, int> xyz_foo = &xyz::foo;
Chris@16: //
Chris@16: //      The template parameter of the member_function_ptr is the return,
Chris@16: //      class and argument types of actual signature of the function to
Chris@16: //      be bound read from left to right:
Chris@16: //
Chris@16: //          void xyz::foo_(int); ---> member_function_ptr<void, xyz, int>
Chris@16: //
Chris@16: //      Take note that a member_function_ptr lazy-function expects the
Chris@16: //      first argument to be a pointer or reference to an object. Both
Chris@16: //      the object (reference or pointer) and the arguments can be
Chris@16: //      lazily bound. Examples:
Chris@16: //
Chris@16: //          xyz obj;
Chris@16: //          xyz_foo(arg1, arg2)   // arg1.foo(arg2)
Chris@16: //          xyz_foo(obj, arg1)    // obj.foo(arg1)
Chris@16: //          xyz_foo(obj, 100)     // obj.foo(100)
Chris@16: //
Chris@16: //      Be reminded that var(obj) must be used to call non-const member
Chris@16: //      functions. For example, if xyz was declared as:
Chris@16: //
Chris@16: //          struct xyz { void foo(int); };
Chris@16: //
Chris@16: //      the pointer or reference to the object must also be non-const.
Chris@16: //      Lazily bound arguments are stored as const value by default (see
Chris@16: //      variable class in primitives.hpp).
Chris@16: //
Chris@16: //          xyz_foo(var(obj), 100)    // obj.foo(100)
Chris@16: //
Chris@16: //      Finally, member variables can be bound much like member
Chris@16: //      functions. For instance, given:
Chris@16: //
Chris@16: //          struct xyz { int v; };
Chris@16: //
Chris@16: //      xyz::v can be bound as:
Chris@16: //
Chris@16: //          bind(&xyz::v)
Chris@16: //      or
Chris@16: //
Chris@16: //          member_var_ptr<int, xyz> xyz_v = &xyz::v;
Chris@16: //
Chris@16: //      The template parameter of the member_var_ptr is the type of the
Chris@16: //      variable followed by the class:
Chris@16: //
Chris@16: //          int xyz::v; ---> member_var_ptr<int, xyz>
Chris@16: //
Chris@16: //      Just like the member_function_ptr, member_var_ptr also expects
Chris@16: //      the first argument to be a pointer or reference to an object.
Chris@16: //      Both the object (reference or pointer) and the arguments can be
Chris@16: //      lazily bound. Examples:
Chris@16: //
Chris@16: //          xyz obj;
Chris@16: //          xyz_v(arg1)   // arg1.v
Chris@16: //          xyz_v(obj)    // obj.v
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Functor binder
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename FuncT>
Chris@16: struct functor_action : public FuncT {
Chris@16: 
Chris@16: #if !defined(__BORLANDC__) && (!defined(__MWERKS__) || (__MWERKS__ > 0x3002))
Chris@16: 
Chris@16:     template <
Chris@16:             typename A = nil_t
Chris@16:         ,   typename B = nil_t
Chris@16:         ,   typename C = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:         ,   typename D = nil_t
Chris@16:         ,   typename E = nil_t
Chris@16:         ,   typename F = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:         ,   typename G = nil_t
Chris@16:         ,   typename H = nil_t
Chris@16:         ,   typename I = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:         ,   typename J = nil_t
Chris@16:         ,   typename K = nil_t
Chris@16:         ,   typename L = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:         ,   typename M = nil_t
Chris@16:         ,   typename N = nil_t
Chris@16:         ,   typename O = nil_t
Chris@16: 
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     >
Chris@16:     struct result { typedef typename FuncT::result_type type; };
Chris@16: #endif
Chris@16: 
Chris@16:     functor_action(FuncT fptr_ = FuncT())
Chris@16:     :   FuncT(fptr_) {}
Chris@16: };
Chris@16: 
Chris@16: #if defined(__BORLANDC__) || (defined(__MWERKS__) && (__MWERKS__ <= 0x3002))
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  The following specializations are needed because Borland and CodeWarrior
Chris@16: //  does not accept default template arguments in nested template classes in
Chris@16: //  classes (i.e functor_action::result)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT>
Chris@16: struct composite0_result<functor_action<FuncT>, TupleT> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A>
Chris@16: struct composite1_result<functor_action<FuncT>, TupleT, A> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A, typename B>
Chris@16: struct composite2_result<functor_action<FuncT>, TupleT, A, B> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A, typename B, typename C>
Chris@16: struct composite3_result<functor_action<FuncT>, TupleT, A, B, C> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A, typename B, typename C, typename D>
Chris@16: struct composite4_result<functor_action<FuncT>, TupleT,
Chris@16:     A, B, C, D> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A, typename B, typename C, typename D, typename E>
Chris@16: struct composite5_result<functor_action<FuncT>, TupleT,
Chris@16:     A, B, C, D, E> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F>
Chris@16: struct composite6_result<functor_action<FuncT>, TupleT,
Chris@16:     A, B, C, D, E, F> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G>
Chris@16: struct composite7_result<functor_action<FuncT>, TupleT,
Chris@16:     A, B, C, D, E, F, G> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H>
Chris@16: struct composite8_result<functor_action<FuncT>, TupleT,
Chris@16:     A, B, C, D, E, F, G, H> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I>
Chris@16: struct composite9_result<functor_action<FuncT>, TupleT,
Chris@16:     A, B, C, D, E, F, G, H, I> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J>
Chris@16: struct composite10_result<functor_action<FuncT>, TupleT,
Chris@16:     A, B, C, D, E, F, G, H, I, J> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K>
Chris@16: struct composite11_result<functor_action<FuncT>, TupleT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L>
Chris@16: struct composite12_result<functor_action<FuncT>, TupleT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L, typename M>
Chris@16: struct composite13_result<functor_action<FuncT>, TupleT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L, M> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L, typename M, typename N>
Chris@16: struct composite14_result<functor_action<FuncT>, TupleT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L, M, N> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT, typename TupleT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L, typename M, typename N, typename O>
Chris@16: struct composite15_result<functor_action<FuncT>, TupleT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> {
Chris@16: 
Chris@16:     typedef typename FuncT::result_type type;
Chris@16: };
Chris@16: 
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT>
Chris@16: struct functor : public function<functor_action<FuncT> > {
Chris@16: 
Chris@16:     functor(FuncT func)
Chris@16:     :   function<functor_action<FuncT> >(functor_action<FuncT>(func)) {};
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename FuncT>
Chris@16: inline functor<FuncT>
Chris@16: bind(FuncT func)
Chris@16: {
Chris@16:     return functor<FuncT>(func);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member variable pointer binder
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: namespace impl {
Chris@16: 
Chris@16:     //////////////////////////////////
Chris@16:     template <typename T>
Chris@16:     struct as_ptr {
Chris@16: 
Chris@16:         typedef T* pointer_type;
Chris@16: 
Chris@16:         static T* get(T& ref)
Chris@16:         { return &ref; }
Chris@16:     };
Chris@16: 
Chris@16:     //////////////////////////////////
Chris@16:     template <typename T>
Chris@16:     struct as_ptr<T*> {
Chris@16: 
Chris@16:         typedef T* pointer_type;
Chris@16: 
Chris@16:         static T* get(T* ptr)
Chris@16:         { return ptr; }
Chris@16:     };
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename ActionT, typename ClassT>
Chris@16: struct member_var_ptr_action_result {
Chris@16: 
Chris@16:     typedef typename ActionT::template result<ClassT>::type type;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename T, typename ClassT>
Chris@16: struct member_var_ptr_action {
Chris@16: 
Chris@16:     typedef member_var_ptr_action<T, ClassT> self_t;
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     struct result {
Chris@16:         typedef typename boost::mpl::if_<boost::is_const<CT>, T const&, T&
Chris@16:             >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     typedef T ClassT::*mem_var_ptr_t;
Chris@16: 
Chris@16:     member_var_ptr_action(mem_var_ptr_t ptr_)
Chris@16:     :   ptr(ptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     typename member_var_ptr_action_result<self_t, CT>::type
Chris@16:     operator()(CT& obj) const
Chris@16:     { return impl::as_ptr<CT>::get(obj)->*ptr; }
Chris@16: 
Chris@16:     mem_var_ptr_t ptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename T, typename ClassT>
Chris@16: struct member_var_ptr
Chris@16: :   public function<member_var_ptr_action<T, ClassT> > {
Chris@16: 
Chris@16:     member_var_ptr(T ClassT::*mp)
Chris@16:     :   function<member_var_ptr_action<T, ClassT> >
Chris@16:         (member_var_ptr_action<T, ClassT>(mp)) {}
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename T, typename ClassT>
Chris@16: inline member_var_ptr<T, ClassT>
Chris@16: bind(T ClassT::*mp)
Chris@16: {
Chris@16:     return member_var_ptr<T, ClassT>(mp);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (main class)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <
Chris@16:     typename RT
Chris@16:     ,   typename A = nil_t
Chris@16:     ,   typename B = nil_t
Chris@16:     ,   typename C = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     ,   typename D = nil_t
Chris@16:     ,   typename E = nil_t
Chris@16:     ,   typename F = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     ,   typename G = nil_t
Chris@16:     ,   typename H = nil_t
Chris@16:     ,   typename I = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     ,   typename J = nil_t
Chris@16:     ,   typename K = nil_t
Chris@16:     ,   typename L = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     ,   typename M = nil_t
Chris@16:     ,   typename N = nil_t
Chris@16:     ,   typename O = nil_t
Chris@16: 
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: 
Chris@16:     ,   typename NU = nil_t  // Not used
Chris@16: >
Chris@16: struct function_ptr_action;
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <
Chris@16:     typename RT
Chris@16:     ,   typename A = nil_t
Chris@16:     ,   typename B = nil_t
Chris@16:     ,   typename C = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     ,   typename D = nil_t
Chris@16:     ,   typename E = nil_t
Chris@16:     ,   typename F = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     ,   typename G = nil_t
Chris@16:     ,   typename H = nil_t
Chris@16:     ,   typename I = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     ,   typename J = nil_t
Chris@16:     ,   typename K = nil_t
Chris@16:     ,   typename L = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     ,   typename M = nil_t
Chris@16:     ,   typename N = nil_t
Chris@16:     ,   typename O = nil_t
Chris@16: 
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: >
Chris@16: struct function_ptr
Chris@16: :   public function<function_ptr_action<RT
Chris@16:     , A, B, C
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     , D, E, F
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     , G, H, I
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     , J, K, L
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     , M, N, O
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     > > {
Chris@16: 
Chris@16:     typedef function_ptr_action<RT
Chris@16:         , A, B, C
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:         , D, E, F
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:         , G, H, I
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:         , J, K, L
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:         , M, N, O
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     > action_t;
Chris@16: 
Chris@16:     template <typename FPT>
Chris@16:     function_ptr(FPT fp)
Chris@16:     :   function<action_t>(action_t(fp)) {}
Chris@16: };
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 0 arg)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT>
Chris@16: struct function_ptr_action<RT,
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)();
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()() const
Chris@16:     { return fptr(); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT>
Chris@16: inline function_ptr<RT>
Chris@16: bind(RT(*fptr)())
Chris@16: {
Chris@16:     return function_ptr<RT>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 1 arg)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename A>
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A);
Chris@16: 
Chris@16:     template <typename A_>
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(A a) const
Chris@16:     { return fptr(a); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename A>
Chris@16: inline function_ptr<RT, A>
Chris@16: bind(RT(*fptr)(A))
Chris@16: {
Chris@16:     return function_ptr<RT, A>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 2 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename A, typename B>
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, B, nil_t,
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A, B);
Chris@16: 
Chris@16:     template <typename A_, typename B_>
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(A a, B b) const
Chris@16:     { return fptr(a, b); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename A, typename B>
Chris@16: inline function_ptr<RT, A, B>
Chris@16: bind(RT(*fptr)(A, B))
Chris@16: {
Chris@16:     return function_ptr<RT, A, B>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 3 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename A, typename B, typename C>
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, B, C,
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A, B, C);
Chris@16: 
Chris@16:     template <typename A_, typename B_, typename C_>
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(A a, B b, C c) const
Chris@16:     { return fptr(a, b, c); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename A, typename B, typename C>
Chris@16: inline function_ptr<RT, A, B, C>
Chris@16: bind(RT(*fptr)(A, B, C))
Chris@16: {
Chris@16:     return function_ptr<RT, A, B, C>(fptr);
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 4 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename A, typename B, typename C, typename D>
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, B, C, D, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A, B, C, D);
Chris@16: 
Chris@16:     template <typename A_, typename B_, typename C_, typename D_>
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(A a, B b, C c, D d) const
Chris@16:     { return fptr(a, b, c, d); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename A, typename B, typename C, typename D>
Chris@16: inline function_ptr<RT, A, B, C, D>
Chris@16: bind(RT(*fptr)(A, B, C, D))
Chris@16: {
Chris@16:     return function_ptr<RT, A, B, C, D>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 5 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E
Chris@16: >
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, B, C, D, E, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A, B, C, D, E);
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_, typename E_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e
Chris@16:     ) const
Chris@16:     { return fptr(a, b, c, d, e); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E
Chris@16: >
Chris@16: inline function_ptr<RT, A, B, C, D, E>
Chris@16: bind(RT(*fptr)(A, B, C, D, E))
Chris@16: {
Chris@16:     return function_ptr<RT, A, B, C, D, E>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 6 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F
Chris@16: >
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, B, C, D, E, F,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A, B, C, D, E, F);
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_, typename E_,
Chris@16:         typename F_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e,
Chris@16:         F f
Chris@16:     ) const
Chris@16:     { return fptr(a, b, c, d, e, f); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F
Chris@16: >
Chris@16: inline function_ptr<RT, A, B, C, D, E, F>
Chris@16: bind(RT(*fptr)(A, B, C, D, E, F))
Chris@16: {
Chris@16:     return function_ptr<RT, A, B, C, D, E, F>(fptr);
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 7 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G
Chris@16: >
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, B, C, D, E, F, G, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A, B, C, D, E, F, G);
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_, typename E_,
Chris@16:         typename F_, typename G_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e,
Chris@16:         F f, G g
Chris@16:     ) const
Chris@16:     { return fptr(a, b, c, d, e, f, g); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G
Chris@16: >
Chris@16: inline function_ptr<RT, A, B, C, D, E, F, G>
Chris@16: bind(RT(*fptr)(A, B, C, D, E, F, G))
Chris@16: {
Chris@16:     return function_ptr<RT, A, B, C, D, E, F, G>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 8 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H
Chris@16: >
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, B, C, D, E, F, G, H, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H);
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_, typename E_,
Chris@16:         typename F_, typename G_, typename H_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e,
Chris@16:         F f, G g, H h
Chris@16:     ) const
Chris@16:     { return fptr(a, b, c, d, e, f, g, h); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H
Chris@16: >
Chris@16: inline function_ptr<RT, A, B, C, D, E, F, G, H>
Chris@16: bind(RT(*fptr)(A, B, C, D, E, F, G, H))
Chris@16: {
Chris@16:     return function_ptr<RT, A, B, C, D, E, F, G, H>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 9 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I
Chris@16: >
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, B, C, D, E, F, G, H, I,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I);
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_, typename E_,
Chris@16:         typename F_, typename G_, typename H_, typename I_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e,
Chris@16:         F f, G g, H h, I i
Chris@16:     ) const
Chris@16:     { return fptr(a, b, c, d, e, f, g, h, i); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I
Chris@16: >
Chris@16: inline function_ptr<RT, A, B, C, D, E, F, G, H, I>
Chris@16: bind(RT(*fptr)(A, B, C, D, E, F, G, H, I))
Chris@16: {
Chris@16:     return function_ptr<RT, A, B, C, D, E, F, G, H, I>(fptr);
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 10 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J
Chris@16: >
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J);
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_, typename E_,
Chris@16:         typename F_, typename G_, typename H_, typename I_, typename J_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e,
Chris@16:         F f, G g, H h, I i, J j
Chris@16:     ) const
Chris@16:     { return fptr(a, b, c, d, e, f, g, h, i, j); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J
Chris@16: >
Chris@16: inline function_ptr<RT, A, B, C, D, E, F, G, H, I, J>
Chris@16: bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J))
Chris@16: {
Chris@16:     return function_ptr<RT, A, B, C, D, E, F, G, H, I, J>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 11 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K
Chris@16: >
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K);
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_, typename E_,
Chris@16:         typename F_, typename G_, typename H_, typename I_, typename J_,
Chris@16:         typename K_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e,
Chris@16:         F f, G g, H h, I i, J j,
Chris@16:         K k
Chris@16:     ) const
Chris@16:     { return fptr(a, b, c, d, e, f, g, h, i, j, k); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K
Chris@16: >
Chris@16: inline function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K>
Chris@16: bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K))
Chris@16: {
Chris@16:     return function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 12 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L
Chris@16: >
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K, L);
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_, typename E_,
Chris@16:         typename F_, typename G_, typename H_, typename I_, typename J_,
Chris@16:         typename K_, typename L_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e,
Chris@16:         F f, G g, H h, I i, J j,
Chris@16:         K k, L l
Chris@16:     ) const
Chris@16:     { return fptr(a, b, c, d, e, f, g, h, i, j, k, l); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L
Chris@16: >
Chris@16: inline function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L>
Chris@16: bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L))
Chris@16: {
Chris@16:     return function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L>(fptr);
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 13 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L, typename M
Chris@16: >
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L, M, nil_t, nil_t, nil_t> {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K, L, M);
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_, typename E_,
Chris@16:         typename F_, typename G_, typename H_, typename I_, typename J_,
Chris@16:         typename K_, typename L_, typename M_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e,
Chris@16:         F f, G g, H h, I i, J j,
Chris@16:         K k, L l, M m
Chris@16:     ) const
Chris@16:     { return fptr(a, b, c, d, e, f, g, h, i, j, k, l, m); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L, typename M
Chris@16: >
Chris@16: inline function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L, M>
Chris@16: bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M))
Chris@16: {
Chris@16:     return function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L, M>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 14 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L, typename M, typename N
Chris@16: >
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L, M, N, nil_t, nil_t> {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_, typename E_,
Chris@16:         typename F_, typename G_, typename H_, typename I_, typename J_,
Chris@16:         typename K_, typename L_, typename M_, typename N_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e,
Chris@16:         F f, G g, H h, I i, J j,
Chris@16:         K k, L l, M m, N n
Chris@16:     ) const
Chris@16:     { return fptr(a, b, c, d, e, f, g, h, i, j, k, l, m, n); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L, typename M, typename N
Chris@16: >
Chris@16: inline function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
Chris@16: bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N))
Chris@16: {
Chris@16:     return function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Function pointer binder (specialization for 15 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L, typename M, typename N, typename O
Chris@16: >
Chris@16: struct function_ptr_action<RT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, nil_t> {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(*func_ptr_t)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_, typename E_,
Chris@16:         typename F_, typename G_, typename H_, typename I_, typename J_,
Chris@16:         typename K_, typename L_, typename M_, typename N_, typename O_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     function_ptr_action(func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e,
Chris@16:         F f, G g, H h, I i, J j,
Chris@16:         K k, L l, M m, N n, O o
Chris@16:     ) const
Chris@16:     { return fptr(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); }
Chris@16: 
Chris@16:     func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT,
Chris@16:     typename A, typename B, typename C, typename D, typename E,
Chris@16:     typename F, typename G, typename H, typename I, typename J,
Chris@16:     typename K, typename L, typename M, typename N, typename O
Chris@16: >
Chris@16: inline function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
Chris@16: bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O))
Chris@16: {
Chris@16:     return function_ptr<RT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(fptr);
Chris@16: }
Chris@16: 
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (main class)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <
Chris@16:     typename RT,
Chris@16:     typename ClassT
Chris@16:     ,   typename A = nil_t
Chris@16:     ,   typename B = nil_t
Chris@16:     ,   typename C = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     ,   typename D = nil_t
Chris@16:     ,   typename E = nil_t
Chris@16:     ,   typename F = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     ,   typename G = nil_t
Chris@16:     ,   typename H = nil_t
Chris@16:     ,   typename I = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     ,   typename J = nil_t
Chris@16:     ,   typename K = nil_t
Chris@16:     ,   typename L = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     ,   typename M = nil_t
Chris@16:     ,   typename N = nil_t
Chris@16:     ,   typename O = nil_t
Chris@16: 
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: 
Chris@16:     ,   typename NU = nil_t  // Not used
Chris@16: >
Chris@16: struct member_function_ptr_action;
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <
Chris@16:     typename RT,
Chris@16:     typename ClassT
Chris@16:     ,   typename A = nil_t
Chris@16:     ,   typename B = nil_t
Chris@16:     ,   typename C = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     ,   typename D = nil_t
Chris@16:     ,   typename E = nil_t
Chris@16:     ,   typename F = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     ,   typename G = nil_t
Chris@16:     ,   typename H = nil_t
Chris@16:     ,   typename I = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     ,   typename J = nil_t
Chris@16:     ,   typename K = nil_t
Chris@16:     ,   typename L = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     ,   typename M = nil_t
Chris@16:     ,   typename N = nil_t
Chris@16:     ,   typename O = nil_t
Chris@16: 
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: >
Chris@16: struct member_function_ptr
Chris@16: :   public function<member_function_ptr_action<RT, ClassT
Chris@16:     , A, B, C
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     , D, E, F
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     , G, H, I
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     , J, K, L
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     , M, N, O
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     > > {
Chris@16: 
Chris@16:     typedef member_function_ptr_action<RT, ClassT
Chris@16:         , A, B, C
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:         , D, E, F
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:         , G, H, I
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:         , J, K, L
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:         , M, N, O
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     > action_t;
Chris@16: 
Chris@16:     template <typename FPT>
Chris@16:     member_function_ptr(FPT fp)
Chris@16:     :   function<action_t>(action_t(fp)) {}
Chris@16: };
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 0 arg)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT>
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)();
Chris@16:     typedef RT(ClassT::*cmf)() const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj) const
Chris@16:     { return (impl::as_ptr<CT>::get(obj)->*fptr)(); }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT>
Chris@16: inline member_function_ptr<RT, ClassT>
Chris@16: bind(RT(ClassT::*fptr)())
Chris@16: {
Chris@16:     return member_function_ptr<RT, ClassT>(fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT>
Chris@16: inline member_function_ptr<RT, ClassT const>
Chris@16: bind(RT(ClassT::*fptr)() const)
Chris@16: {
Chris@16:     return member_function_ptr<RT, ClassT const>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 1 arg)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A>
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A);
Chris@16:     typedef RT(ClassT::*cmf)(A) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT, typename A_>
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj, A a) const
Chris@16:     { return (impl::as_ptr<CT>::get(obj)->*fptr)(a); }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A>
Chris@16: inline member_function_ptr<RT, ClassT, A>
Chris@16: bind(RT(ClassT::*fptr)(A))
Chris@16: {
Chris@16:     return member_function_ptr<RT, ClassT, A>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A>
Chris@16: inline member_function_ptr<RT, ClassT const, A>
Chris@16: bind(RT(ClassT::*fptr)(A) const)
Chris@16: {
Chris@16:     return member_function_ptr<RT, ClassT const, A>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 2 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A, typename B>
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, B, nil_t,
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B);
Chris@16:     typedef RT(ClassT::*cmf)(A, B) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT, typename A_, typename B_>
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj, A a, B b) const
Chris@16:     { return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b); }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A, typename B>
Chris@16: inline member_function_ptr<RT, ClassT, A, B>
Chris@16: bind(RT(ClassT::*fptr)(A, B))
Chris@16: {
Chris@16:     return member_function_ptr<RT, ClassT, A, B>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A, typename B>
Chris@16: inline member_function_ptr<RT, ClassT const, A, B>
Chris@16: bind(RT(ClassT::*fptr)(A, B) const)
Chris@16: {
Chris@16:     return member_function_ptr<RT, ClassT const, A, B>(fptr);
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 3 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A, typename B, typename C>
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, B, C, nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT, typename A_, typename B_, typename C_>
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj, A a, B b, C c) const
Chris@16:     { return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c); }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A, typename B, typename C>
Chris@16: inline member_function_ptr<RT, ClassT, A, B, C>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C))
Chris@16: {
Chris@16:     return member_function_ptr<RT, ClassT, A, B, C>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A, typename B, typename C>
Chris@16: inline member_function_ptr<RT, ClassT const, A, B, C>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C) const)
Chris@16: {
Chris@16:     return member_function_ptr<RT, ClassT const, A, B, C>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 4 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D
Chris@16: >
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, B, C, D, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT,
Chris@16:         typename A_, typename B_, typename C_, typename D_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj,
Chris@16:         A a, B b, C c, D d
Chris@16:     ) const
Chris@16:     { return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d); }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT, A, B, C, D>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D))
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT, A, B, C, D>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT const, A, B, C, D>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D) const)
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT const, A, B, C, D>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 5 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E
Chris@16: >
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, B, C, D, E, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT,
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj,
Chris@16:         A a, B b, C c, D d, E e
Chris@16:     ) const
Chris@16:     { return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d, e); }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT, A, B, C, D, E>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E))
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT, A, B, C, D, E>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT const, A, B, C, D, E>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E) const)
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT const, A, B, C, D, E>(fptr);
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 6 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F
Chris@16: >
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT,
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj,
Chris@16:         A a, B b, C c, D d, E e, F f
Chris@16:     ) const
Chris@16:     { return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d, e, f); }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT, A, B, C, D, E, F>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F))
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT, A, B, C, D, E, F>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F) const)
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT const, A, B, C, D, E, F>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 7 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G
Chris@16: >
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT,
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj,
Chris@16:         A a, B b, C c, D d, E e, F f, G g
Chris@16:     ) const
Chris@16:     { return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d, e, f, g); }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G))
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G) const)
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 8 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H
Chris@16: >
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT,
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj,
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h
Chris@16:     ) const
Chris@16:     { return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d, e, f, g, h); }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H))
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H) const)
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H>(fptr);
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 9 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I
Chris@16: >
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, I, nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT,
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_, typename I_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj,
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h, I i
Chris@16:     ) const
Chris@16:     { return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d, e, f, g, h, i); }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I))
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I) const)
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 10 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J
Chris@16: >
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT,
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_, typename I_,
Chris@16:         typename J_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj,
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h, I i, J j
Chris@16:     ) const
Chris@16:     {
Chris@16:         return (impl::as_ptr<CT>::get(obj)->*fptr)
Chris@16:             (a, b, c, d, e, f, g, h, i, j);
Chris@16:     }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J))
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I, J>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J) const)
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 11 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K
Chris@16: >
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT,
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_, typename I_,
Chris@16:         typename J_, typename K_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj,
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k
Chris@16:     ) const
Chris@16:     {
Chris@16:         return (impl::as_ptr<CT>::get(obj)->*fptr)
Chris@16:             (a, b, c, d, e, f, g, h, i, j, k);
Chris@16:     }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K))
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K) const)
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>(fptr);
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 12 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L
Chris@16: >
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L, nil_t, nil_t, nil_t, nil_t> {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT,
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_, typename I_,
Chris@16:         typename J_, typename K_, typename L_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj,
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l
Chris@16:     ) const
Chris@16:     {
Chris@16:         return (impl::as_ptr<CT>::get(obj)->*fptr)
Chris@16:             (a, b, c, d, e, f, g, h, i, j, k, l);
Chris@16:     }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L))
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L) const)
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 13 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M
Chris@16: >
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L, M, nil_t, nil_t, nil_t> {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT,
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_, typename I_,
Chris@16:         typename J_, typename K_, typename L_, typename M_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj,
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m
Chris@16:     ) const
Chris@16:     {
Chris@16:         return (impl::as_ptr<CT>::get(obj)->*fptr)
Chris@16:             (a, b, c, d, e, f, g, h, i, j, k, l, m);
Chris@16:     }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M))
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M) const)
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 14 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N
Chris@16: >
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L, M, N, nil_t, nil_t> {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT,
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_, typename I_,
Chris@16:         typename J_, typename K_, typename L_, typename M_, typename N_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj,
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n
Chris@16:     ) const
Chris@16:     {
Chris@16:         return (impl::as_ptr<CT>::get(obj)->*fptr)
Chris@16:             (a, b, c, d, e, f, g, h, i, j, k, l, m, n);
Chris@16:     }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N))
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const)
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Member function pointer binder (specialization for 15 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N,
Chris@16:     typename O
Chris@16: >
Chris@16: struct member_function_ptr_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, nil_t> {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT,
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_, typename I_,
Chris@16:         typename J_, typename K_, typename L_, typename M_, typename N_,
Chris@16:         typename O_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     member_function_ptr_action(mem_func_ptr_t fptr_)
Chris@16:     :   fptr(fptr_) {}
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     result_type operator()(CT& obj,
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o
Chris@16:     ) const
Chris@16:     {
Chris@16:         return (impl::as_ptr<CT>::get(obj)->*fptr)
Chris@16:             (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
Chris@16:     }
Chris@16: 
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N,
Chris@16:     typename O
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O))
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N,
Chris@16:     typename O
Chris@16: >
Chris@16: inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
Chris@16: bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const)
Chris@16: {
Chris@16:     return member_function_ptr<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(fptr);
Chris@16: }
Chris@16: 
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (main class)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <
Chris@16:     typename RT,
Chris@16:     typename ClassT
Chris@16:     ,   typename A = nil_t
Chris@16:     ,   typename B = nil_t
Chris@16:     ,   typename C = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     ,   typename D = nil_t
Chris@16:     ,   typename E = nil_t
Chris@16:     ,   typename F = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     ,   typename G = nil_t
Chris@16:     ,   typename H = nil_t
Chris@16:     ,   typename I = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     ,   typename J = nil_t
Chris@16:     ,   typename K = nil_t
Chris@16:     ,   typename L = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     ,   typename M = nil_t
Chris@16:     ,   typename N = nil_t
Chris@16:     ,   typename O = nil_t
Chris@16: 
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: 
Chris@16:     ,   typename NU = nil_t  // Not used
Chris@16: >
Chris@16: struct bound_member_action;
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <
Chris@16:     typename RT,
Chris@16:     typename ClassT
Chris@16:     ,   typename A = nil_t
Chris@16:     ,   typename B = nil_t
Chris@16:     ,   typename C = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     ,   typename D = nil_t
Chris@16:     ,   typename E = nil_t
Chris@16:     ,   typename F = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     ,   typename G = nil_t
Chris@16:     ,   typename H = nil_t
Chris@16:     ,   typename I = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     ,   typename J = nil_t
Chris@16:     ,   typename K = nil_t
Chris@16:     ,   typename L = nil_t
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     ,   typename M = nil_t
Chris@16:     ,   typename N = nil_t
Chris@16:     ,   typename O = nil_t
Chris@16: 
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: >
Chris@16: struct bound_member
Chris@16: :   public function<bound_member_action<RT, ClassT
Chris@16:     , A, B, C
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     , D, E, F
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     , G, H, I
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     , J, K, L
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     , M, N, O
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     > > {
Chris@16: 
Chris@16:     typedef bound_member_action<RT, ClassT
Chris@16:         , A, B, C
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:         , D, E, F
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:         , G, H, I
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:         , J, K, L
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:         , M, N, O
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     > action_t;
Chris@16: 
Chris@16:     template <typename CT, typename FPT>
Chris@16:     bound_member(CT & c, FPT fp)
Chris@16:     :   function<action_t>(action_t(c,fp)) {}
Chris@16: 
Chris@16: #if !defined(__BORLANDC__)
Chris@16:     template <typename CT, typename FPT>
Chris@16:     bound_member(CT * c, FPT fp)
Chris@16:     :   function<action_t>(action_t(c,fp)) {}
Chris@16: #endif
Chris@16: };
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 0 arg)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: 
Chris@16: template <typename RT, typename ClassT>
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)();
Chris@16:     typedef RT(ClassT::*cmf)() const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()() const
Chris@16:     { return (obj->*fptr)(); }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: 
Chris@16: template <typename RT, typename ClassT>
Chris@16: inline bound_member<RT,ClassT>
Chris@16: bind(ClassT & obj, RT(ClassT::*fptr)())
Chris@16: {
Chris@16:     return bound_member<RT,ClassT>(obj, fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT>
Chris@16: inline bound_member<RT,ClassT>
Chris@16: bind(ClassT * obj, RT(ClassT::*fptr)())
Chris@16: {
Chris@16: #if defined(__MWERKS__) && (__MWERKS__ < 0x3003)
Chris@16:     return bound_member<RT,ClassT>(*obj, fptr);
Chris@16: #else
Chris@16:     return bound_member<RT,ClassT>(obj, fptr);
Chris@16: #endif
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT>
Chris@16: inline bound_member<RT,ClassT const>
Chris@16: bind(ClassT const& obj, RT(ClassT::*fptr)())
Chris@16: {
Chris@16:     return bound_member<RT,ClassT const>(obj, fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT>
Chris@16: inline bound_member<RT,ClassT const>
Chris@16: bind(ClassT  const* obj, RT(ClassT::*fptr)() const)
Chris@16: {
Chris@16: #if defined(__MWERKS__) && (__MWERKS__ < 0x3003)
Chris@16:     return bound_member<RT,ClassT const>(*obj, fptr);
Chris@16: #else
Chris@16:     return bound_member<RT,ClassT const>(obj, fptr);
Chris@16: #endif
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 1 arg)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A>
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A);
Chris@16:     typedef RT(ClassT::*cmf)(A) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename A_>
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(A a) const
Chris@16:     { return (obj->*fptr)(a); }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A>
Chris@16: inline bound_member<RT, ClassT, A>
Chris@16: bind(ClassT & obj, RT(ClassT::*fptr)(A))
Chris@16: {
Chris@16:     return bound_member<RT, ClassT, A>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT, typename A>
Chris@16: inline bound_member<RT, ClassT, A>
Chris@16: bind(ClassT * obj, RT(ClassT::*fptr)(A))
Chris@16: {
Chris@16:     return bound_member<RT, ClassT, A>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A>
Chris@16: inline bound_member<RT, ClassT const, A>
Chris@16: bind(ClassT const& obj, RT(ClassT::*fptr)(A) const)
Chris@16: {
Chris@16:     return bound_member<RT, ClassT const, A>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT, typename A>
Chris@16: inline bound_member<RT, ClassT const, A>
Chris@16: bind(ClassT const* obj, RT(ClassT::*fptr)(A) const)
Chris@16: {
Chris@16:     return bound_member<RT, ClassT const, A>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 2 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A, typename B>
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, B, nil_t,
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B);
Chris@16:     typedef RT(ClassT::*cmf)(A, B) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename A_, typename B_>
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(A a, B b) const
Chris@16:     { return (obj->*fptr)(a, b); }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A, typename B>
Chris@16: inline bound_member<RT, ClassT, A, B>
Chris@16: bind(ClassT & obj,RT(ClassT::*fptr)(A, B))
Chris@16: {
Chris@16:     return bound_member<RT, ClassT, A, B>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT, typename A, typename B>
Chris@16: inline bound_member<RT, ClassT, A, B>
Chris@16: bind(ClassT * obj,RT(ClassT::*fptr)(A, B))
Chris@16: {
Chris@16:     return bound_member<RT, ClassT, A, B>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT, typename A, typename B>
Chris@16: inline bound_member<RT, ClassT const, A, B>
Chris@16: bind(ClassT const& obj,RT(ClassT::*fptr)(A, B) const)
Chris@16: {
Chris@16:     return bound_member<RT, ClassT const, A, B>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT, typename A, typename B>
Chris@16: inline bound_member<RT, ClassT const, A, B>
Chris@16: bind(ClassT const* obj,RT(ClassT::*fptr)(A, B) const)
Chris@16: {
Chris@16:     return bound_member<RT, ClassT const, A, B>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 3
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 3 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A, typename B, typename C>
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, B, C, nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename A_, typename B_, typename C_>
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(A a, B b, C c) const
Chris@16:     { return (obj->*fptr)(a, b, c); }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT, typename A, typename B, typename C>
Chris@16: inline bound_member<RT, ClassT, A, B, C>
Chris@16: bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C))
Chris@16: {
Chris@16:     return bound_member<RT, ClassT, A, B, C>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT, typename A, typename B, typename C>
Chris@16: inline bound_member<RT, ClassT, A, B, C>
Chris@16: bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C))
Chris@16: {
Chris@16:     return bound_member<RT, ClassT, A, B, C>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT, typename A, typename B, typename C>
Chris@16: inline bound_member<RT, ClassT const, A, B, C>
Chris@16: bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C) const)
Chris@16: {
Chris@16:     return bound_member<RT, ClassT const, A, B, C>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT, typename A, typename B, typename C>
Chris@16: inline bound_member<RT, ClassT const, A, B, C>
Chris@16: bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C) const)
Chris@16: {
Chris@16:     return bound_member<RT, ClassT const, A, B, C>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 4 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D
Chris@16: >
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, B, C, D, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename A_, typename B_, typename C_, typename D_>
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(A a, B b, C c, D d) const
Chris@16:     { return (obj->*fptr)(a, b, c, d); }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D>
Chris@16: bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D>
Chris@16: bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D>
Chris@16: bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D>
Chris@16: bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 5 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E
Chris@16: >
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, B, C, D, E, nil_t,
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e
Chris@16:     ) const
Chris@16:     { return (obj->*fptr)(a, b, c, d, e); }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E>
Chris@16: bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E>
Chris@16: bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E>
Chris@16: bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E>
Chris@16: bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 6
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 6 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F
Chris@16: >
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e, F f
Chris@16:     ) const
Chris@16:     { return (obj->*fptr)(a, b, c, d, e, f); }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F>
Chris@16: bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F>
Chris@16: bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F>
Chris@16: bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F>
Chris@16: bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 7 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G
Chris@16: >
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e, F f, G g
Chris@16:     ) const
Chris@16:     { return (obj->*fptr)(a, b, c, d, e, f, g); }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G>
Chris@16: bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G>
Chris@16: bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G>
Chris@16: bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G>
Chris@16: bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 8 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H
Chris@16: >
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, nil_t,
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h
Chris@16:     ) const
Chris@16:     { return (obj->*fptr)(a, b, c, d, e, f, g, h); }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H>
Chris@16: bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H>
Chris@16: bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H>
Chris@16: bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H>
Chris@16: bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 9
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 9 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I
Chris@16: >
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, I, nil_t, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_, typename I_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h, I i
Chris@16:     ) const
Chris@16:     { return (obj->*fptr)(a, b, c, d, e, f, g, h, i); }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I>
Chris@16: bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I>
Chris@16: bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I>
Chris@16: bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I>
Chris@16: bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 10 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J
Chris@16: >
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, nil_t, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_, typename I_,
Chris@16:         typename J_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h, I i, J j
Chris@16:     ) const
Chris@16:     {
Chris@16:         return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j);
Chris@16:     }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J>
Chris@16: bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J>
Chris@16: bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J>
Chris@16: bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J>
Chris@16: bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 11 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K
Chris@16: >
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, nil_t,
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16:     nil_t, nil_t, nil_t,
Chris@16: #endif
Chris@16:     nil_t   //  Unused
Chris@16: > {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_, typename I_,
Chris@16:         typename J_, typename K_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k
Chris@16:     ) const
Chris@16:     {
Chris@16:         return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k);
Chris@16:     }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>
Chris@16: bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>
Chris@16: bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>
Chris@16: bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>
Chris@16: bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: #if PHOENIX_LIMIT > 12
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 12 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L
Chris@16: >
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L, nil_t, nil_t, nil_t, nil_t> {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_, typename I_,
Chris@16:         typename J_, typename K_, typename L_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l
Chris@16:     ) const
Chris@16:     {
Chris@16:         return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k, l);
Chris@16:     }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>
Chris@16: bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>
Chris@16: bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>
Chris@16: bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>
Chris@16: bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 13 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M
Chris@16: >
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L, M, nil_t, nil_t, nil_t> {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_, typename I_,
Chris@16:         typename J_, typename K_, typename L_, typename M_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m
Chris@16:     ) const
Chris@16:     {
Chris@16:         return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k, l, m);
Chris@16:     }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>
Chris@16: bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>
Chris@16: bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>
Chris@16: bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>
Chris@16: bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 14 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N
Chris@16: >
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L, M, N, nil_t, nil_t> {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_, typename I_,
Chris@16:         typename J_, typename K_, typename L_, typename M_, typename N_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n
Chris@16:     ) const
Chris@16:     {
Chris@16:         return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
Chris@16:     }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
Chris@16: bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
Chris@16: bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
Chris@16: bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>
Chris@16: bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Bound member function binder (specialization for 15 args)
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N,
Chris@16:     typename O
Chris@16: >
Chris@16: struct bound_member_action<RT, ClassT,
Chris@16:     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, nil_t> {
Chris@16: 
Chris@16:     typedef RT result_type;
Chris@16:     typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
Chris@16:     typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const;
Chris@16:     typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
Chris@16:         mem_func_ptr_t;
Chris@16: 
Chris@16:     template <
Chris@16:         typename A_, typename B_, typename C_, typename D_,
Chris@16:         typename E_, typename F_, typename G_, typename H_, typename I_,
Chris@16:         typename J_, typename K_, typename L_, typename M_, typename N_,
Chris@16:         typename O_
Chris@16:     >
Chris@16:     struct result { typedef result_type type; };
Chris@16: 
Chris@16:     template <typename CT>
Chris@16:     bound_member_action(CT & obj_, mem_func_ptr_t fptr_)
Chris@16:     :   obj(impl::as_ptr<CT>::get(obj_)), fptr(fptr_) {}
Chris@16: 
Chris@16:     result_type operator()(
Chris@16:         A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o
Chris@16:     ) const
Chris@16:     {
Chris@16:         return (obj->*fptr)(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
Chris@16:     }
Chris@16: 
Chris@16:     typename impl::as_ptr<ClassT>::pointer_type obj;
Chris@16:     mem_func_ptr_t fptr;
Chris@16: };
Chris@16: 
Chris@16: //////////////////////////////////
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N,
Chris@16:     typename O
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
Chris@16: bind(ClassT & obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N,
Chris@16:     typename O
Chris@16: >
Chris@16: inline bound_member<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
Chris@16: bind(ClassT * obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O))
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N,
Chris@16:     typename O
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
Chris@16: bind(ClassT const& obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: template <typename RT, typename ClassT,
Chris@16:     typename A, typename B, typename C, typename D,
Chris@16:     typename E, typename F, typename G, typename H, typename I,
Chris@16:     typename J, typename K, typename L, typename M, typename N,
Chris@16:     typename O
Chris@16: >
Chris@16: inline bound_member<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>
Chris@16: bind(ClassT const* obj,RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) const)
Chris@16: {
Chris@16:     return bound_member<
Chris@16:         RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(obj,fptr);
Chris@16: }
Chris@16: 
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: #endif
Chris@16: 
Chris@16: }   //  namespace phoenix
Chris@16: 
Chris@16: #endif