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