x
Yes
No
Do you want to visit DriveHQ English website?
Inicio
Características
Precios
Prueba gratuita
Software cliente
Acerca de nosotros
Servidor de archivos
|
Solución de copias de seguridad
|
Servidor FTP
|
Servidor de correo electrónico
|
Alojamiento web
|
Software cliente
Servidor de archivos
Solución de copia de seguridad
Servidor FTP
Servidor de correo electrónico
Alojamiento web
Software cliente
binders.hpp - Hosted on DriveHQ Cloud IT Platform
Arriba
Subir
Descargar
Compartir
Publicar
Nueva carpeta
Nuevo archivo
Copiar
Cortar
Eliminar
Pegar
Clasificación
Actualizar
Ruta de la carpeta: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\spirit\phoenix\binders.hpp
Girar
Efecto
Propiedad
Historial
/*============================================================================= 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