diff -r 000000000000 -r bde4ae8d615e os/ossrv/ossrv_pub/boost_apis/boost/spirit/phoenix/binders.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/ossrv_pub/boost_apis/boost/spirit/phoenix/binders.hpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,4067 @@ +/*============================================================================= + Phoenix v1.2 + Copyright (c) 2001-2002 Joel de Guzman + + Use, modification and distribution is subject to 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 +#include +#include + +/////////////////////////////////////////////////////////////////////////////// +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 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 +// +// 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): +// +// bind(std::plus()) +// +// or +// +// functor > plus; +// +// Again, these are full-fledged lazy functions. In this case, +// unlike the first example, expect 2 arguments (std::plus +// 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 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 +// +// 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 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 +// +// 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 +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 +struct composite0_result, TupleT> { + + typedef typename FuncT::result_type type; +}; + +////////////////////////////////// +template +struct composite1_result, TupleT, A> { + + typedef typename FuncT::result_type type; +}; + +////////////////////////////////// +template +struct composite2_result, TupleT, A, B> { + + typedef typename FuncT::result_type type; +}; + +////////////////////////////////// +template +struct composite3_result, TupleT, A, B, C> { + + typedef typename FuncT::result_type type; +}; + +#if PHOENIX_LIMIT > 3 +////////////////////////////////// +template +struct composite4_result, TupleT, + A, B, C, D> { + + typedef typename FuncT::result_type type; +}; + +////////////////////////////////// +template +struct composite5_result, TupleT, + A, B, C, D, E> { + + typedef typename FuncT::result_type type; +}; + +////////////////////////////////// +template +struct composite6_result, TupleT, + A, B, C, D, E, F> { + + typedef typename FuncT::result_type type; +}; + +#if PHOENIX_LIMIT > 6 +////////////////////////////////// +template +struct composite7_result, TupleT, + A, B, C, D, E, F, G> { + + typedef typename FuncT::result_type type; +}; + +////////////////////////////////// +template +struct composite8_result, TupleT, + A, B, C, D, E, F, G, H> { + + typedef typename FuncT::result_type type; +}; + +////////////////////////////////// +template +struct composite9_result, TupleT, + A, B, C, D, E, F, G, H, I> { + + typedef typename FuncT::result_type type; +}; + +#if PHOENIX_LIMIT > 9 +////////////////////////////////// +template +struct composite10_result, TupleT, + A, B, C, D, E, F, G, H, I, J> { + + typedef typename FuncT::result_type type; +}; + +////////////////////////////////// +template +struct composite11_result, TupleT, + A, B, C, D, E, F, G, H, I, J, K> { + + typedef typename FuncT::result_type type; +}; + +////////////////////////////////// +template +struct composite12_result, TupleT, + A, B, C, D, E, F, G, H, I, J, K, L> { + + typedef typename FuncT::result_type type; +}; + +#if PHOENIX_LIMIT > 12 +////////////////////////////////// +template +struct composite13_result, TupleT, + A, B, C, D, E, F, G, H, I, J, K, L, M> { + + typedef typename FuncT::result_type type; +}; + +////////////////////////////////// +template +struct composite14_result, TupleT, + A, B, C, D, E, F, G, H, I, J, K, L, M, N> { + + typedef typename FuncT::result_type type; +}; + +////////////////////////////////// +template +struct composite15_result, 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 +struct functor : public function > { + + functor(FuncT func) + : function >(functor_action(func)) {}; +}; + +////////////////////////////////// +template +inline functor +bind(FuncT func) +{ + return functor(func); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Member variable pointer binder +// +/////////////////////////////////////////////////////////////////////////////// +namespace impl { + + ////////////////////////////////// + template + struct as_ptr { + + typedef T* pointer_type; + + static T* get(T& ref) + { return &ref; } + }; + + ////////////////////////////////// + template + struct as_ptr { + + typedef T* pointer_type; + + static T* get(T* ptr) + { return ptr; } + }; +} + +////////////////////////////////// +template +struct member_var_ptr_action_result { + + typedef typename ActionT::template result::type type; +}; + +////////////////////////////////// +template +struct member_var_ptr_action { + + typedef member_var_ptr_action self_t; + + template + struct result { + typedef typename boost::mpl::if_, 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 member_var_ptr_action_result::type + operator()(CT& obj) const + { return impl::as_ptr::get(obj)->*ptr; } + + mem_var_ptr_t ptr; +}; + +////////////////////////////////// +template +struct member_var_ptr +: public function > { + + member_var_ptr(T ClassT::*mp) + : function > + (member_var_ptr_action(mp)) {} +}; + +////////////////////////////////// +template +inline member_var_ptr +bind(T ClassT::*mp) +{ + return member_var_ptr(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 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 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 + function_ptr(FPT fp) + : function(action_t(fp)) {} +}; + +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 0 arg) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action 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 +inline function_ptr +bind(RT(*fptr)()) +{ + return function_ptr(fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 1 arg) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action 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 + 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 +inline function_ptr +bind(RT(*fptr)(A)) +{ + return function_ptr(fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 2 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action 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 + 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 +inline function_ptr +bind(RT(*fptr)(A, B)) +{ + return function_ptr(fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 3 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action 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 + 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 +inline function_ptr +bind(RT(*fptr)(A, B, C)) +{ + return function_ptr(fptr); +} + +#if PHOENIX_LIMIT > 3 +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 4 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action 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 + 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 +inline function_ptr +bind(RT(*fptr)(A, B, C, D)) +{ + return function_ptr(fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 5 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action 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 +inline function_ptr +bind(RT(*fptr)(A, B, C, D, E)) +{ + return function_ptr(fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 6 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action 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 +inline function_ptr +bind(RT(*fptr)(A, B, C, D, E, F)) +{ + return function_ptr(fptr); +} + +#if PHOENIX_LIMIT > 6 +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 7 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action 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 +inline function_ptr +bind(RT(*fptr)(A, B, C, D, E, F, G)) +{ + return function_ptr(fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 8 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action 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 +inline function_ptr +bind(RT(*fptr)(A, B, C, D, E, F, G, H)) +{ + return function_ptr(fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 9 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action 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 +inline function_ptr +bind(RT(*fptr)(A, B, C, D, E, F, G, H, I)) +{ + return function_ptr(fptr); +} + +#if PHOENIX_LIMIT > 9 +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 10 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action 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 +inline function_ptr +bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J)) +{ + return function_ptr(fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 11 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action 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 +inline function_ptr +bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K)) +{ + return function_ptr(fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 12 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action 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 +inline function_ptr +bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L)) +{ + return function_ptr(fptr); +} + +#if PHOENIX_LIMIT > 12 +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 13 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action { + + 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 +inline function_ptr +bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M)) +{ + return function_ptr(fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 14 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action { + + 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 +inline function_ptr +bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N)) +{ + return function_ptr(fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Function pointer binder (specialization for 15 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct function_ptr_action { + + 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 +inline function_ptr +bind(RT(*fptr)(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)) +{ + return function_ptr(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 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 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 + member_function_ptr(FPT fp) + : function(action_t(fp)) {} +}; + +/////////////////////////////////////////////////////////////////////////////// +// +// Member function pointer binder (specialization for 0 arg) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct member_function_ptr_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + result_type operator()(CT& obj) const + { return (impl::as_ptr::get(obj)->*fptr)(); } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +bind(RT(ClassT::*fptr)()) +{ + return member_function_ptr(fptr); +} + +template +inline member_function_ptr +bind(RT(ClassT::*fptr)() const) +{ + return member_function_ptr(fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Member function pointer binder (specialization for 1 arg) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct member_function_ptr_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + result_type operator()(CT& obj, A a) const + { return (impl::as_ptr::get(obj)->*fptr)(a); } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +bind(RT(ClassT::*fptr)(A)) +{ + return member_function_ptr(fptr); +} + +////////////////////////////////// +template +inline member_function_ptr +bind(RT(ClassT::*fptr)(A) const) +{ + return member_function_ptr(fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Member function pointer binder (specialization for 2 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct member_function_ptr_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + result_type operator()(CT& obj, A a, B b) const + { return (impl::as_ptr::get(obj)->*fptr)(a, b); } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +bind(RT(ClassT::*fptr)(A, B)) +{ + return member_function_ptr(fptr); +} + +////////////////////////////////// +template +inline member_function_ptr +bind(RT(ClassT::*fptr)(A, B) const) +{ + return member_function_ptr(fptr); +} + +#if PHOENIX_LIMIT > 3 +/////////////////////////////////////////////////////////////////////////////// +// +// Member function pointer binder (specialization for 3 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct member_function_ptr_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + result_type operator()(CT& obj, A a, B b, C c) const + { return (impl::as_ptr::get(obj)->*fptr)(a, b, c); } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +bind(RT(ClassT::*fptr)(A, B, C)) +{ + return member_function_ptr(fptr); +} + +////////////////////////////////// +template +inline member_function_ptr +bind(RT(ClassT::*fptr)(A, B, C) const) +{ + return member_function_ptr(fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Member function pointer binder (specialization for 4 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct member_function_ptr_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + result_type operator()(CT& obj, + A a, B b, C c, D d + ) const + { return (impl::as_ptr::get(obj)->*fptr)(a, b, c, d); } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +bind(RT(ClassT::*fptr)(A, B, C, D)) +{ + return member_function_ptr< + RT, ClassT, A, B, C, D>(fptr); +} + +////////////////////////////////// +template +inline member_function_ptr +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 +struct member_function_ptr_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + result_type operator()(CT& obj, + A a, B b, C c, D d, E e + ) const + { return (impl::as_ptr::get(obj)->*fptr)(a, b, c, d, e); } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +bind(RT(ClassT::*fptr)(A, B, C, D, E)) +{ + return member_function_ptr< + RT, ClassT, A, B, C, D, E>(fptr); +} + +////////////////////////////////// +template +inline member_function_ptr +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 +struct member_function_ptr_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + result_type operator()(CT& obj, + A a, B b, C c, D d, E e, F f + ) const + { return (impl::as_ptr::get(obj)->*fptr)(a, b, c, d, e, f); } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +bind(RT(ClassT::*fptr)(A, B, C, D, E, F)) +{ + return member_function_ptr< + RT, ClassT, A, B, C, D, E, F>(fptr); +} + +////////////////////////////////// +template +inline member_function_ptr +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 +struct member_function_ptr_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + result_type operator()(CT& obj, + A a, B b, C c, D d, E e, F f, G g + ) const + { return (impl::as_ptr::get(obj)->*fptr)(a, b, c, d, e, f, g); } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +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 +inline member_function_ptr +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 +struct member_function_ptr_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + 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::get(obj)->*fptr)(a, b, c, d, e, f, g, h); } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +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 +inline member_function_ptr +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 +struct member_function_ptr_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + 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::get(obj)->*fptr)(a, b, c, d, e, f, g, h, i); } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +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 +inline member_function_ptr +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 +struct member_function_ptr_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + 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::get(obj)->*fptr) + (a, b, c, d, e, f, g, h, i, j); + } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +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 +inline member_function_ptr +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 +struct member_function_ptr_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + 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::get(obj)->*fptr) + (a, b, c, d, e, f, g, h, i, j, k); + } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +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 +inline member_function_ptr +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 +struct member_function_ptr_action { + + 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + 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::get(obj)->*fptr) + (a, b, c, d, e, f, g, h, i, j, k, l); + } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +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 +inline member_function_ptr +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 +struct member_function_ptr_action { + + 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + 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::get(obj)->*fptr) + (a, b, c, d, e, f, g, h, i, j, k, l, m); + } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +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 +inline member_function_ptr +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 +struct member_function_ptr_action { + + 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + 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::get(obj)->*fptr) + (a, b, c, d, e, f, g, h, i, j, k, l, m, n); + } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +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 +inline member_function_ptr +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 +struct member_function_ptr_action { + + 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + member_function_ptr_action(mem_func_ptr_t fptr_) + : fptr(fptr_) {} + + template + 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::get(obj)->*fptr) + (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); + } + + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline member_function_ptr +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 +inline member_function_ptr +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 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 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 + bound_member(CT & c, FPT fp) + : function(action_t(c,fp)) {} + +#if !defined(__BORLANDC__) + template + bound_member(CT * c, FPT fp) + : function(action_t(c,fp)) {} +#endif +}; + +/////////////////////////////////////////////////////////////////////////////// +// +// Bound member function binder (specialization for 0 arg) +// +/////////////////////////////////////////////////////////////////////////////// + +template +struct bound_member_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + template + bound_member_action(CT & obj_, mem_func_ptr_t fptr_) + : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} + + result_type operator()() const + { return (obj->*fptr)(); } + + typename impl::as_ptr::pointer_type obj; + mem_func_ptr_t fptr; +}; + +////////////////////////////////// + +template +inline bound_member +bind(ClassT & obj, RT(ClassT::*fptr)()) +{ + return bound_member(obj, fptr); +} + +template +inline bound_member +bind(ClassT * obj, RT(ClassT::*fptr)()) +{ +#if defined(__MWERKS__) && (__MWERKS__ < 0x3003) + return bound_member(*obj, fptr); +#else + return bound_member(obj, fptr); +#endif +} + +template +inline bound_member +bind(ClassT const& obj, RT(ClassT::*fptr)()) +{ + return bound_member(obj, fptr); +} + +template +inline bound_member +bind(ClassT const* obj, RT(ClassT::*fptr)() const) +{ +#if defined(__MWERKS__) && (__MWERKS__ < 0x3003) + return bound_member(*obj, fptr); +#else + return bound_member(obj, fptr); +#endif +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Bound member function binder (specialization for 1 arg) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct bound_member_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + template + bound_member_action(CT & obj_, mem_func_ptr_t fptr_) + : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} + + result_type operator()(A a) const + { return (obj->*fptr)(a); } + + typename impl::as_ptr::pointer_type obj; + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline bound_member +bind(ClassT & obj, RT(ClassT::*fptr)(A)) +{ + return bound_member(obj,fptr); +} + +template +inline bound_member +bind(ClassT * obj, RT(ClassT::*fptr)(A)) +{ + return bound_member(obj,fptr); +} + +////////////////////////////////// +template +inline bound_member +bind(ClassT const& obj, RT(ClassT::*fptr)(A) const) +{ + return bound_member(obj,fptr); +} + +template +inline bound_member +bind(ClassT const* obj, RT(ClassT::*fptr)(A) const) +{ + return bound_member(obj,fptr); +} + +/////////////////////////////////////////////////////////////////////////////// +// +// Bound member function binder (specialization for 2 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct bound_member_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template + struct result { typedef result_type type; }; + + template + bound_member_action(CT & obj_, mem_func_ptr_t fptr_) + : obj(impl::as_ptr::get(obj_)), fptr(fptr_) {} + + result_type operator()(A a, B b) const + { return (obj->*fptr)(a, b); } + + typename impl::as_ptr::pointer_type obj; + mem_func_ptr_t fptr; +}; + +////////////////////////////////// +template +inline bound_member +bind(ClassT & obj,RT(ClassT::*fptr)(A, B)) +{ + return bound_member(obj,fptr); +} + +template +inline bound_member +bind(ClassT * obj,RT(ClassT::*fptr)(A, B)) +{ + return bound_member(obj,fptr); +} + +template +inline bound_member +bind(ClassT const& obj,RT(ClassT::*fptr)(A, B) const) +{ + return bound_member(obj,fptr); +} + +template +inline bound_member +bind(ClassT const* obj,RT(ClassT::*fptr)(A, B) const) +{ + return bound_member(obj,fptr); +} + +#if PHOENIX_LIMIT > 3 +/////////////////////////////////////////////////////////////////////////////// +// +// Bound member function binder (specialization for 3 args) +// +/////////////////////////////////////////////////////////////////////////////// +template +struct bound_member_action 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_, cmf, mf>::type + mem_func_ptr_t; + + template