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