Generated on: Thu Mar 29 07:46:58 PDT 2012 for custom file set
// doxy/ or-tools/ src/ base/

or-tools/src/base/callback.h File Reference

#include "base/logging.h"

Go to the source code of this file.

Namespaces

namespace  operations_research

Classes

struct  operations_research::CallbackUtils_
class  Closure
 base types More...
class  ResultCallback< R >
class  Callback1< A1 >
class  ResultCallback1< R, A1 >
class  Callback2< A1, A2 >
class  ResultCallback2< R, A1, A2 >
class  Callback3< A1, A2, A3 >
class  ResultCallback3< R, A1, A2, A3 >
class  Callback4< A1, A2, A3, A4 >
class  ResultCallback4< R, A1, A2, A3, A4 >
class  Callback5< A1, A2, A3, A4, A5 >
class  ResultCallback5< R, A1, A2, A3, A4, A5 >

Functions

template<class T1, class T2, class R>
_ConstMemberResultCallback_0_0
< true, R, T1 >::base * 		NewCallback (const T1 *obj, R(T2::*member)() const)
template<class T1, class T2, class R>
_ConstMemberResultCallback_0_0
< false, R, T1 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)() const)
template<class T1, class T2, class R>
_MemberResultCallback_0_0
< true, R, T1 >::base * 		NewCallback (T1 *obj, R(T2::*member)())
template<class T1, class T2, class R>
_MemberResultCallback_0_0
< false, R, T1 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)())
template<class R>
_FunctionResultCallback_0_0
< true, R >::base * 		NewCallback (R(*function)())
 namespace
template<class R>
_FunctionResultCallback_0_0
< false, R >::base * 		NewPermanentCallback (R(*function)())
template<class T1, class T2, class R, class P1>
_ConstMemberResultCallback_1_0
< true, R, T1, P1 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1) const, P1 p1)
 namespace
template<class T1, class T2, class R, class P1>
_ConstMemberResultCallback_1_0
< false, R, T1, P1 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1) const, P1 p1)
template<class T1, class T2, class R, class P1>
_MemberResultCallback_1_0
< true, R, T1, P1 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1), P1 p1)
 namespace
template<class T1, class T2, class R, class P1>
_MemberResultCallback_1_0
< false, R, T1, P1 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1), P1 p1)
template<class R, class P1>
_FunctionResultCallback_1_0
< true, R, P1 >::base * 		NewCallback (R(*function)(P1), P1 p1)
 namespace
template<class R, class P1>
_FunctionResultCallback_1_0
< false, R, P1 >::base * 		NewPermanentCallback (R(*function)(P1), P1 p1)
template<class T1, class T2, class R, class P1, class P2>
_ConstMemberResultCallback_2_0
< true, R, T1, P1, P2 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2) const, P1 p1, P2 p2)
 namespace
template<class T1, class T2, class R, class P1, class P2>
_ConstMemberResultCallback_2_0
< false, R, T1, P1, P2 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2) const, P1 p1, P2 p2)
template<class T1, class T2, class R, class P1, class P2>
_MemberResultCallback_2_0
< true, R, T1, P1, P2 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2), P1 p1, P2 p2)
 namespace
template<class T1, class T2, class R, class P1, class P2>
_MemberResultCallback_2_0
< false, R, T1, P1, P2 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2), P1 p1, P2 p2)
template<class R, class P1, class P2>
_FunctionResultCallback_2_0
< true, R, P1, P2 >::base * 		NewCallback (R(*function)(P1, P2), P1 p1, P2 p2)
 namespace
template<class R, class P1, class P2>
_FunctionResultCallback_2_0
< false, R, P1, P2 >::base * 		NewPermanentCallback (R(*function)(P1, P2), P1 p1, P2 p2)
template<class T1, class T2, class R, class P1, class P2, class P3>
_ConstMemberResultCallback_3_0
< true, R, T1, P1, P2, P3 >
::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3) const, P1 p1, P2 p2, P3 p3)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3>
_ConstMemberResultCallback_3_0
< false, R, T1, P1, P2, P3 >
::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3) const, P1 p1, P2 p2, P3 p3)
template<class T1, class T2, class R, class P1, class P2, class P3>
_MemberResultCallback_3_0
< true, R, T1, P1, P2, P3 >
::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3), P1 p1, P2 p2, P3 p3)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3>
_MemberResultCallback_3_0
< false, R, T1, P1, P2, P3 >
::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3), P1 p1, P2 p2, P3 p3)
template<class R, class P1, class P2, class P3>
_FunctionResultCallback_3_0
< true, R, P1, P2, P3 >::base * 		NewCallback (R(*function)(P1, P2, P3), P1 p1, P2 p2, P3 p3)
 namespace
template<class R, class P1, class P2, class P3>
_FunctionResultCallback_3_0
< false, R, P1, P2, P3 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3), P1 p1, P2 p2, P3 p3)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4>
_ConstMemberResultCallback_4_0
< true, R, T1, P1, P2, P3, P4 >
::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4) const, P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4>
_ConstMemberResultCallback_4_0
< false, R, T1, P1, P2, P3, P4 >
::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4) const, P1 p1, P2 p2, P3 p3, P4 p4)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4>
_MemberResultCallback_4_0
< true, R, T1, P1, P2, P3, P4 >
::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4), P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4>
_MemberResultCallback_4_0
< false, R, T1, P1, P2, P3, P4 >
::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4), P1 p1, P2 p2, P3 p3, P4 p4)
template<class R, class P1, class P2, class P3, class P4>
_FunctionResultCallback_4_0
< true, R, P1, P2, P3, P4 >
::base * 		NewCallback (R(*function)(P1, P2, P3, P4), P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class R, class P1, class P2, class P3, class P4>
_FunctionResultCallback_4_0
< false, R, P1, P2, P3, P4 >
::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4), P1 p1, P2 p2, P3 p3, P4 p4)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
_ConstMemberResultCallback_5_0
< true, R, T1, P1, P2, P3, P4,
P5 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
_ConstMemberResultCallback_5_0
< false, R, T1, P1, P2, P3, P4,
P5 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
_MemberResultCallback_5_0
< true, R, T1, P1, P2, P3, P4,
P5 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
_MemberResultCallback_5_0
< false, R, T1, P1, P2, P3, P4,
P5 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class R, class P1, class P2, class P3, class P4, class P5>
_FunctionResultCallback_5_0
< true, R, P1, P2, P3, P4, P5 >
::base * 		NewCallback (R(*function)(P1, P2, P3, P4, P5), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class R, class P1, class P2, class P3, class P4, class P5>
_FunctionResultCallback_5_0
< false, R, P1, P2, P3, P4, P5 >
::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, P5), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
_ConstMemberResultCallback_6_0
< true, R, T1, P1, P2, P3, P4,
P5, P6 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
_ConstMemberResultCallback_6_0
< false, R, T1, P1, P2, P3, P4,
P5, P6 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
_MemberResultCallback_6_0
< true, R, T1, P1, P2, P3, P4,
P5, P6 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
_MemberResultCallback_6_0
< false, R, T1, P1, P2, P3, P4,
P5, P6 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class R, class P1, class P2, class P3, class P4, class P5, class P6>
_FunctionResultCallback_6_0
< true, R, P1, P2, P3, P4, P5,
P6 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, P5, P6), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class R, class P1, class P2, class P3, class P4, class P5, class P6>
_FunctionResultCallback_6_0
< false, R, P1, P2, P3, P4, P5,
P6 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, P5, P6), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class T1, class T2, class R, class A1>
_ConstMemberResultCallback_0_1
< true, R, T1, A1 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(A1) const)
 namespace
template<class T1, class T2, class R, class A1>
_ConstMemberResultCallback_0_1
< false, R, T1, A1 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(A1) const)
template<class T1, class T2, class R, class A1>
_MemberResultCallback_0_1
< true, R, T1, A1 >::base * 		NewCallback (T1 *obj, R(T2::*member)(A1))
 namespace
template<class T1, class T2, class R, class A1>
_MemberResultCallback_0_1
< false, R, T1, A1 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(A1))
template<class R, class A1>
_FunctionResultCallback_0_1
< true, R, A1 >::base * 		NewCallback (R(*function)(A1))
 namespace
template<class R, class A1>
_FunctionResultCallback_0_1
< false, R, A1 >::base * 		NewPermanentCallback (R(*function)(A1))
template<class T1, class T2, class R, class P1, class A1>
_ConstMemberResultCallback_1_1
< true, R, T1, P1, A1 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, A1) const, P1 p1)
 namespace
template<class T1, class T2, class R, class P1, class A1>
_ConstMemberResultCallback_1_1
< false, R, T1, P1, A1 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, A1) const, P1 p1)
template<class T1, class T2, class R, class P1, class A1>
_MemberResultCallback_1_1
< true, R, T1, P1, A1 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, A1), P1 p1)
 namespace
template<class T1, class T2, class R, class P1, class A1>
_MemberResultCallback_1_1
< false, R, T1, P1, A1 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, A1), P1 p1)
template<class R, class P1, class A1>
_FunctionResultCallback_1_1
< true, R, P1, A1 >::base * 		NewCallback (R(*function)(P1, A1), P1 p1)
 namespace
template<class R, class P1, class A1>
_FunctionResultCallback_1_1
< false, R, P1, A1 >::base * 		NewPermanentCallback (R(*function)(P1, A1), P1 p1)
template<class T1, class T2, class R, class P1, class P2, class A1>
_ConstMemberResultCallback_2_1
< true, R, T1, P1, P2, A1 >
::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, A1) const, P1 p1, P2 p2)
 namespace
template<class T1, class T2, class R, class P1, class P2, class A1>
_ConstMemberResultCallback_2_1
< false, R, T1, P1, P2, A1 >
::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, A1) const, P1 p1, P2 p2)
template<class T1, class T2, class R, class P1, class P2, class A1>
_MemberResultCallback_2_1
< true, R, T1, P1, P2, A1 >
::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, A1), P1 p1, P2 p2)
 namespace
template<class T1, class T2, class R, class P1, class P2, class A1>
_MemberResultCallback_2_1
< false, R, T1, P1, P2, A1 >
::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, A1), P1 p1, P2 p2)
template<class R, class P1, class P2, class A1>
_FunctionResultCallback_2_1
< true, R, P1, P2, A1 >::base * 		NewCallback (R(*function)(P1, P2, A1), P1 p1, P2 p2)
 namespace
template<class R, class P1, class P2, class A1>
_FunctionResultCallback_2_1
< false, R, P1, P2, A1 >::base * 		NewPermanentCallback (R(*function)(P1, P2, A1), P1 p1, P2 p2)
template<class T1, class T2, class R, class P1, class P2, class P3, class A1>
_ConstMemberResultCallback_3_1
< true, R, T1, P1, P2, P3, A1 >
::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, A1) const, P1 p1, P2 p2, P3 p3)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class A1>
_ConstMemberResultCallback_3_1
< false, R, T1, P1, P2, P3, A1 >
::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, A1) const, P1 p1, P2 p2, P3 p3)
template<class T1, class T2, class R, class P1, class P2, class P3, class A1>
_MemberResultCallback_3_1
< true, R, T1, P1, P2, P3, A1 >
::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, A1), P1 p1, P2 p2, P3 p3)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class A1>
_MemberResultCallback_3_1
< false, R, T1, P1, P2, P3, A1 >
::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, A1), P1 p1, P2 p2, P3 p3)
template<class R, class P1, class P2, class P3, class A1>
_FunctionResultCallback_3_1
< true, R, P1, P2, P3, A1 >
::base * 		NewCallback (R(*function)(P1, P2, P3, A1), P1 p1, P2 p2, P3 p3)
 namespace
template<class R, class P1, class P2, class P3, class A1>
_FunctionResultCallback_3_1
< false, R, P1, P2, P3, A1 >
::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, A1), P1 p1, P2 p2, P3 p3)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
_ConstMemberResultCallback_4_1
< true, R, T1, P1, P2, P3, P4,
A1 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1) const, P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
_ConstMemberResultCallback_4_1
< false, R, T1, P1, P2, P3, P4,
A1 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1) const, P1 p1, P2 p2, P3 p3, P4 p4)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
_MemberResultCallback_4_1
< true, R, T1, P1, P2, P3, P4,
A1 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1), P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
_MemberResultCallback_4_1
< false, R, T1, P1, P2, P3, P4,
A1 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1), P1 p1, P2 p2, P3 p3, P4 p4)
template<class R, class P1, class P2, class P3, class P4, class A1>
_FunctionResultCallback_4_1
< true, R, P1, P2, P3, P4, A1 >
::base * 		NewCallback (R(*function)(P1, P2, P3, P4, A1), P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class R, class P1, class P2, class P3, class P4, class A1>
_FunctionResultCallback_4_1
< false, R, P1, P2, P3, P4, A1 >
::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, A1), P1 p1, P2 p2, P3 p3, P4 p4)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
_ConstMemberResultCallback_5_1
< true, R, T1, P1, P2, P3, P4,
P5, A1 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
_ConstMemberResultCallback_5_1
< false, R, T1, P1, P2, P3, P4,
P5, A1 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
_MemberResultCallback_5_1
< true, R, T1, P1, P2, P3, P4,
P5, A1 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
_MemberResultCallback_5_1
< false, R, T1, P1, P2, P3, P4,
P5, A1 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class R, class P1, class P2, class P3, class P4, class P5, class A1>
_FunctionResultCallback_5_1
< true, R, P1, P2, P3, P4, P5,
A1 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, P5, A1), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class R, class P1, class P2, class P3, class P4, class P5, class A1>
_FunctionResultCallback_5_1
< false, R, P1, P2, P3, P4, P5,
A1 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, P5, A1), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
_ConstMemberResultCallback_6_1
< true, R, T1, P1, P2, P3, P4,
P5, P6, A1 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
_ConstMemberResultCallback_6_1
< false, R, T1, P1, P2, P3, P4,
P5, P6, A1 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
_MemberResultCallback_6_1
< true, R, T1, P1, P2, P3, P4,
P5, P6, A1 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
_MemberResultCallback_6_1
< false, R, T1, P1, P2, P3, P4,
P5, P6, A1 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
_FunctionResultCallback_6_1
< true, R, P1, P2, P3, P4, P5,
P6, A1 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, P5, P6, A1), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
_FunctionResultCallback_6_1
< false, R, P1, P2, P3, P4, P5,
P6, A1 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, P5, P6, A1), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class T1, class T2, class R, class A1, class A2>
_ConstMemberResultCallback_0_2
< true, R, T1, A1, A2 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(A1, A2) const)
 namespace
template<class T1, class T2, class R, class A1, class A2>
_ConstMemberResultCallback_0_2
< false, R, T1, A1, A2 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(A1, A2) const)
template<class T1, class T2, class R, class A1, class A2>
_MemberResultCallback_0_2
< true, R, T1, A1, A2 >::base * 		NewCallback (T1 *obj, R(T2::*member)(A1, A2))
 namespace
template<class T1, class T2, class R, class A1, class A2>
_MemberResultCallback_0_2
< false, R, T1, A1, A2 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(A1, A2))
template<class R, class A1, class A2>
_FunctionResultCallback_0_2
< true, R, A1, A2 >::base * 		NewCallback (R(*function)(A1, A2))
 namespace
template<class R, class A1, class A2>
_FunctionResultCallback_0_2
< false, R, A1, A2 >::base * 		NewPermanentCallback (R(*function)(A1, A2))
template<class T1, class T2, class R, class P1, class A1, class A2>
_ConstMemberResultCallback_1_2
< true, R, T1, P1, A1, A2 >
::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, A1, A2) const, P1 p1)
 namespace
template<class T1, class T2, class R, class P1, class A1, class A2>
_ConstMemberResultCallback_1_2
< false, R, T1, P1, A1, A2 >
::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, A1, A2) const, P1 p1)
template<class T1, class T2, class R, class P1, class A1, class A2>
_MemberResultCallback_1_2
< true, R, T1, P1, A1, A2 >
::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, A1, A2), P1 p1)
 namespace
template<class T1, class T2, class R, class P1, class A1, class A2>
_MemberResultCallback_1_2
< false, R, T1, P1, A1, A2 >
::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, A1, A2), P1 p1)
template<class R, class P1, class A1, class A2>
_FunctionResultCallback_1_2
< true, R, P1, A1, A2 >::base * 		NewCallback (R(*function)(P1, A1, A2), P1 p1)
 namespace
template<class R, class P1, class A1, class A2>
_FunctionResultCallback_1_2
< false, R, P1, A1, A2 >::base * 		NewPermanentCallback (R(*function)(P1, A1, A2), P1 p1)
template<class T1, class T2, class R, class P1, class P2, class A1, class A2>
_ConstMemberResultCallback_2_2
< true, R, T1, P1, P2, A1, A2 >
::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, A1, A2) const, P1 p1, P2 p2)
 namespace
template<class T1, class T2, class R, class P1, class P2, class A1, class A2>
_ConstMemberResultCallback_2_2
< false, R, T1, P1, P2, A1, A2 >
::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, A1, A2) const, P1 p1, P2 p2)
template<class T1, class T2, class R, class P1, class P2, class A1, class A2>
_MemberResultCallback_2_2
< true, R, T1, P1, P2, A1, A2 >
::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, A1, A2), P1 p1, P2 p2)
 namespace
template<class T1, class T2, class R, class P1, class P2, class A1, class A2>
_MemberResultCallback_2_2
< false, R, T1, P1, P2, A1, A2 >
::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, A1, A2), P1 p1, P2 p2)
template<class R, class P1, class P2, class A1, class A2>
_FunctionResultCallback_2_2
< true, R, P1, P2, A1, A2 >
::base * 		NewCallback (R(*function)(P1, P2, A1, A2), P1 p1, P2 p2)
 namespace
template<class R, class P1, class P2, class A1, class A2>
_FunctionResultCallback_2_2
< false, R, P1, P2, A1, A2 >
::base * 		NewPermanentCallback (R(*function)(P1, P2, A1, A2), P1 p1, P2 p2)
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
_ConstMemberResultCallback_3_2
< true, R, T1, P1, P2, P3, A1,
A2 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2) const, P1 p1, P2 p2, P3 p3)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
_ConstMemberResultCallback_3_2
< false, R, T1, P1, P2, P3, A1,
A2 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2) const, P1 p1, P2 p2, P3 p3)
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
_MemberResultCallback_3_2
< true, R, T1, P1, P2, P3, A1,
A2 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2), P1 p1, P2 p2, P3 p3)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
_MemberResultCallback_3_2
< false, R, T1, P1, P2, P3, A1,
A2 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2), P1 p1, P2 p2, P3 p3)
template<class R, class P1, class P2, class P3, class A1, class A2>
_FunctionResultCallback_3_2
< true, R, P1, P2, P3, A1, A2 >
::base * 		NewCallback (R(*function)(P1, P2, P3, A1, A2), P1 p1, P2 p2, P3 p3)
 namespace
template<class R, class P1, class P2, class P3, class A1, class A2>
_FunctionResultCallback_3_2
< false, R, P1, P2, P3, A1, A2 >
::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, A1, A2), P1 p1, P2 p2, P3 p3)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
_ConstMemberResultCallback_4_2
< true, R, T1, P1, P2, P3, P4,
A1, A2 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2) const, P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
_ConstMemberResultCallback_4_2
< false, R, T1, P1, P2, P3, P4,
A1, A2 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2) const, P1 p1, P2 p2, P3 p3, P4 p4)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
_MemberResultCallback_4_2
< true, R, T1, P1, P2, P3, P4,
A1, A2 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2), P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
_MemberResultCallback_4_2
< false, R, T1, P1, P2, P3, P4,
A1, A2 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2), P1 p1, P2 p2, P3 p3, P4 p4)
template<class R, class P1, class P2, class P3, class P4, class A1, class A2>
_FunctionResultCallback_4_2
< true, R, P1, P2, P3, P4, A1,
A2 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, A1, A2), P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class R, class P1, class P2, class P3, class P4, class A1, class A2>
_FunctionResultCallback_4_2
< false, R, P1, P2, P3, P4, A1,
A2 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, A1, A2), P1 p1, P2 p2, P3 p3, P4 p4)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
_ConstMemberResultCallback_5_2
< true, R, T1, P1, P2, P3, P4,
P5, A1, A2 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
_ConstMemberResultCallback_5_2
< false, R, T1, P1, P2, P3, P4,
P5, A1, A2 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
_MemberResultCallback_5_2
< true, R, T1, P1, P2, P3, P4,
P5, A1, A2 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
_MemberResultCallback_5_2
< false, R, T1, P1, P2, P3, P4,
P5, A1, A2 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
_FunctionResultCallback_5_2
< true, R, P1, P2, P3, P4, P5,
A1, A2 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, P5, A1, A2), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
_FunctionResultCallback_5_2
< false, R, P1, P2, P3, P4, P5,
A1, A2 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, P5, A1, A2), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
_ConstMemberResultCallback_6_2
< true, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
_ConstMemberResultCallback_6_2
< false, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
_MemberResultCallback_6_2
< true, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
_MemberResultCallback_6_2
< false, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
_FunctionResultCallback_6_2
< true, R, P1, P2, P3, P4, P5,
P6, A1, A2 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, P5, P6, A1, A2), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
_FunctionResultCallback_6_2
< false, R, P1, P2, P3, P4, P5,
P6, A1, A2 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, P5, P6, A1, A2), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class T1, class T2, class R, class A1, class A2, class A3>
_ConstMemberResultCallback_0_3
< true, R, T1, A1, A2, A3 >
::base * 		NewCallback (const T1 *obj, R(T2::*member)(A1, A2, A3) const)
 namespace
template<class T1, class T2, class R, class A1, class A2, class A3>
_ConstMemberResultCallback_0_3
< false, R, T1, A1, A2, A3 >
::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(A1, A2, A3) const)
template<class T1, class T2, class R, class A1, class A2, class A3>
_MemberResultCallback_0_3
< true, R, T1, A1, A2, A3 >
::base * 		NewCallback (T1 *obj, R(T2::*member)(A1, A2, A3))
 namespace
template<class T1, class T2, class R, class A1, class A2, class A3>
_MemberResultCallback_0_3
< false, R, T1, A1, A2, A3 >
::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(A1, A2, A3))
template<class R, class A1, class A2, class A3>
_FunctionResultCallback_0_3
< true, R, A1, A2, A3 >::base * 		NewCallback (R(*function)(A1, A2, A3))
 namespace
template<class R, class A1, class A2, class A3>
_FunctionResultCallback_0_3
< false, R, A1, A2, A3 >::base * 		NewPermanentCallback (R(*function)(A1, A2, A3))
template<class T1, class T2, class R, class P1, class A1, class A2, class A3>
_ConstMemberResultCallback_1_3
< true, R, T1, P1, A1, A2, A3 >
::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, A1, A2, A3) const, P1 p1)
 namespace
template<class T1, class T2, class R, class P1, class A1, class A2, class A3>
_ConstMemberResultCallback_1_3
< false, R, T1, P1, A1, A2, A3 >
::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, A1, A2, A3) const, P1 p1)
template<class T1, class T2, class R, class P1, class A1, class A2, class A3>
_MemberResultCallback_1_3
< true, R, T1, P1, A1, A2, A3 >
::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, A1, A2, A3), P1 p1)
 namespace
template<class T1, class T2, class R, class P1, class A1, class A2, class A3>
_MemberResultCallback_1_3
< false, R, T1, P1, A1, A2, A3 >
::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, A1, A2, A3), P1 p1)
template<class R, class P1, class A1, class A2, class A3>
_FunctionResultCallback_1_3
< true, R, P1, A1, A2, A3 >
::base * 		NewCallback (R(*function)(P1, A1, A2, A3), P1 p1)
 namespace
template<class R, class P1, class A1, class A2, class A3>
_FunctionResultCallback_1_3
< false, R, P1, A1, A2, A3 >
::base * 		NewPermanentCallback (R(*function)(P1, A1, A2, A3), P1 p1)
template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
_ConstMemberResultCallback_2_3
< true, R, T1, P1, P2, A1, A2,
A3 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, A1, A2, A3) const, P1 p1, P2 p2)
 namespace
template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
_ConstMemberResultCallback_2_3
< false, R, T1, P1, P2, A1, A2,
A3 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, A1, A2, A3) const, P1 p1, P2 p2)
template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
_MemberResultCallback_2_3
< true, R, T1, P1, P2, A1, A2,
A3 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, A1, A2, A3), P1 p1, P2 p2)
 namespace
template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
_MemberResultCallback_2_3
< false, R, T1, P1, P2, A1, A2,
A3 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, A1, A2, A3), P1 p1, P2 p2)
template<class R, class P1, class P2, class A1, class A2, class A3>
_FunctionResultCallback_2_3
< true, R, P1, P2, A1, A2, A3 >
::base * 		NewCallback (R(*function)(P1, P2, A1, A2, A3), P1 p1, P2 p2)
 namespace
template<class R, class P1, class P2, class A1, class A2, class A3>
_FunctionResultCallback_2_3
< false, R, P1, P2, A1, A2, A3 >
::base * 		NewPermanentCallback (R(*function)(P1, P2, A1, A2, A3), P1 p1, P2 p2)
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
_ConstMemberResultCallback_3_3
< true, R, T1, P1, P2, P3, A1,
A2, A3 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2, A3) const, P1 p1, P2 p2, P3 p3)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
_ConstMemberResultCallback_3_3
< false, R, T1, P1, P2, P3, A1,
A2, A3 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2, A3) const, P1 p1, P2 p2, P3 p3)
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
_MemberResultCallback_3_3
< true, R, T1, P1, P2, P3, A1,
A2, A3 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2, A3), P1 p1, P2 p2, P3 p3)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
_MemberResultCallback_3_3
< false, R, T1, P1, P2, P3, A1,
A2, A3 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2, A3), P1 p1, P2 p2, P3 p3)
template<class R, class P1, class P2, class P3, class A1, class A2, class A3>
_FunctionResultCallback_3_3
< true, R, P1, P2, P3, A1, A2,
A3 >::base * 		NewCallback (R(*function)(P1, P2, P3, A1, A2, A3), P1 p1, P2 p2, P3 p3)
 namespace
template<class R, class P1, class P2, class P3, class A1, class A2, class A3>
_FunctionResultCallback_3_3
< false, R, P1, P2, P3, A1, A2,
A3 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, A1, A2, A3), P1 p1, P2 p2, P3 p3)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
_ConstMemberResultCallback_4_3
< true, R, T1, P1, P2, P3, P4,
A1, A2, A3 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2, A3) const, P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
_ConstMemberResultCallback_4_3
< false, R, T1, P1, P2, P3, P4,
A1, A2, A3 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2, A3) const, P1 p1, P2 p2, P3 p3, P4 p4)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
_MemberResultCallback_4_3
< true, R, T1, P1, P2, P3, P4,
A1, A2, A3 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2, A3), P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
_MemberResultCallback_4_3
< false, R, T1, P1, P2, P3, P4,
A1, A2, A3 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2, A3), P1 p1, P2 p2, P3 p3, P4 p4)
template<class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
_FunctionResultCallback_4_3
< true, R, P1, P2, P3, P4, A1,
A2, A3 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, A1, A2, A3), P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
_FunctionResultCallback_4_3
< false, R, P1, P2, P3, P4, A1,
A2, A3 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, A1, A2, A3), P1 p1, P2 p2, P3 p3, P4 p4)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
_ConstMemberResultCallback_5_3
< true, R, T1, P1, P2, P3, P4,
P5, A1, A2, A3 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
_ConstMemberResultCallback_5_3
< false, R, T1, P1, P2, P3, P4,
P5, A1, A2, A3 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
_MemberResultCallback_5_3
< true, R, T1, P1, P2, P3, P4,
P5, A1, A2, A3 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
_MemberResultCallback_5_3
< false, R, T1, P1, P2, P3, P4,
P5, A1, A2, A3 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
_FunctionResultCallback_5_3
< true, R, P1, P2, P3, P4, P5,
A1, A2, A3 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, P5, A1, A2, A3), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
_FunctionResultCallback_5_3
< false, R, P1, P2, P3, P4, P5,
A1, A2, A3 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, P5, A1, A2, A3), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
_ConstMemberResultCallback_6_3
< true, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2, A3 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
_ConstMemberResultCallback_6_3
< false, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2, A3 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
_MemberResultCallback_6_3
< true, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2, A3 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
_MemberResultCallback_6_3
< false, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2, A3 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
_FunctionResultCallback_6_3
< true, R, P1, P2, P3, P4, P5,
P6, A1, A2, A3 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, P5, P6, A1, A2, A3), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
_FunctionResultCallback_6_3
< false, R, P1, P2, P3, P4, P5,
P6, A1, A2, A3 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, P5, P6, A1, A2, A3), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class T1, class T2, class R, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_0_4
< true, R, T1, A1, A2, A3, A4 >
::base * 		NewCallback (const T1 *obj, R(T2::*member)(A1, A2, A3, A4) const)
 namespace
template<class T1, class T2, class R, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_0_4
< false, R, T1, A1, A2, A3, A4 >
::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(A1, A2, A3, A4) const)
template<class T1, class T2, class R, class A1, class A2, class A3, class A4>
_MemberResultCallback_0_4
< true, R, T1, A1, A2, A3, A4 >
::base * 		NewCallback (T1 *obj, R(T2::*member)(A1, A2, A3, A4))
 namespace
template<class T1, class T2, class R, class A1, class A2, class A3, class A4>
_MemberResultCallback_0_4
< false, R, T1, A1, A2, A3, A4 >
::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(A1, A2, A3, A4))
template<class R, class A1, class A2, class A3, class A4>
_FunctionResultCallback_0_4
< true, R, A1, A2, A3, A4 >
::base * 		NewCallback (R(*function)(A1, A2, A3, A4))
 namespace
template<class R, class A1, class A2, class A3, class A4>
_FunctionResultCallback_0_4
< false, R, A1, A2, A3, A4 >
::base * 		NewPermanentCallback (R(*function)(A1, A2, A3, A4))
template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_1_4
< true, R, T1, P1, A1, A2, A3,
A4 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, A1, A2, A3, A4) const, P1 p1)
 namespace
template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_1_4
< false, R, T1, P1, A1, A2, A3,
A4 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, A1, A2, A3, A4) const, P1 p1)
template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
_MemberResultCallback_1_4
< true, R, T1, P1, A1, A2, A3,
A4 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, A1, A2, A3, A4), P1 p1)
 namespace
template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
_MemberResultCallback_1_4
< false, R, T1, P1, A1, A2, A3,
A4 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, A1, A2, A3, A4), P1 p1)
template<class R, class P1, class A1, class A2, class A3, class A4>
_FunctionResultCallback_1_4
< true, R, P1, A1, A2, A3, A4 >
::base * 		NewCallback (R(*function)(P1, A1, A2, A3, A4), P1 p1)
 namespace
template<class R, class P1, class A1, class A2, class A3, class A4>
_FunctionResultCallback_1_4
< false, R, P1, A1, A2, A3, A4 >
::base * 		NewPermanentCallback (R(*function)(P1, A1, A2, A3, A4), P1 p1)
template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_2_4
< true, R, T1, P1, P2, A1, A2,
A3, A4 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, A1, A2, A3, A4) const, P1 p1, P2 p2)
 namespace
template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_2_4
< false, R, T1, P1, P2, A1, A2,
A3, A4 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, A1, A2, A3, A4) const, P1 p1, P2 p2)
template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
_MemberResultCallback_2_4
< true, R, T1, P1, P2, A1, A2,
A3, A4 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, A1, A2, A3, A4), P1 p1, P2 p2)
 namespace
template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
_MemberResultCallback_2_4
< false, R, T1, P1, P2, A1, A2,
A3, A4 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, A1, A2, A3, A4), P1 p1, P2 p2)
template<class R, class P1, class P2, class A1, class A2, class A3, class A4>
_FunctionResultCallback_2_4
< true, R, P1, P2, A1, A2, A3,
A4 >::base * 		NewCallback (R(*function)(P1, P2, A1, A2, A3, A4), P1 p1, P2 p2)
 namespace
template<class R, class P1, class P2, class A1, class A2, class A3, class A4>
_FunctionResultCallback_2_4
< false, R, P1, P2, A1, A2, A3,
A4 >::base * 		NewPermanentCallback (R(*function)(P1, P2, A1, A2, A3, A4), P1 p1, P2 p2)
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_3_4
< true, R, T1, P1, P2, P3, A1,
A2, A3, A4 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2, A3, A4) const, P1 p1, P2 p2, P3 p3)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_3_4
< false, R, T1, P1, P2, P3, A1,
A2, A3, A4 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2, A3, A4) const, P1 p1, P2 p2, P3 p3)
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
_MemberResultCallback_3_4
< true, R, T1, P1, P2, P3, A1,
A2, A3, A4 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
_MemberResultCallback_3_4
< false, R, T1, P1, P2, P3, A1,
A2, A3, A4 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3)
template<class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
_FunctionResultCallback_3_4
< true, R, P1, P2, P3, A1, A2,
A3, A4 >::base * 		NewCallback (R(*function)(P1, P2, P3, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3)
 namespace
template<class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
_FunctionResultCallback_3_4
< false, R, P1, P2, P3, A1, A2,
A3, A4 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_4_4
< true, R, T1, P1, P2, P3, P4,
A1, A2, A3, A4 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4) const, P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_4_4
< false, R, T1, P1, P2, P3, P4,
A1, A2, A3, A4 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4) const, P1 p1, P2 p2, P3 p3, P4 p4)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
_MemberResultCallback_4_4
< true, R, T1, P1, P2, P3, P4,
A1, A2, A3, A4 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
_MemberResultCallback_4_4
< false, R, T1, P1, P2, P3, P4,
A1, A2, A3, A4 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3, P4 p4)
template<class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
_FunctionResultCallback_4_4
< true, R, P1, P2, P3, P4, A1,
A2, A3, A4 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
_FunctionResultCallback_4_4
< false, R, P1, P2, P3, P4, A1,
A2, A3, A4 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3, P4 p4)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_5_4
< true, R, T1, P1, P2, P3, P4,
P5, A1, A2, A3, A4 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_5_4
< false, R, T1, P1, P2, P3, P4,
P5, A1, A2, A3, A4 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
_MemberResultCallback_5_4
< true, R, T1, P1, P2, P3, P4,
P5, A1, A2, A3, A4 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
_MemberResultCallback_5_4
< false, R, T1, P1, P2, P3, P4,
P5, A1, A2, A3, A4 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
_FunctionResultCallback_5_4
< true, R, P1, P2, P3, P4, P5,
A1, A2, A3, A4 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, P5, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
_FunctionResultCallback_5_4
< false, R, P1, P2, P3, P4, P5,
A1, A2, A3, A4 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, P5, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_6_4
< true, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2, A3, A4 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_6_4
< false, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2, A3, A4 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
_MemberResultCallback_6_4
< true, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2, A3, A4 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
_MemberResultCallback_6_4
< false, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2, A3, A4 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
_FunctionResultCallback_6_4
< true, R, P1, P2, P3, P4, P5,
P6, A1, A2, A3, A4 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
_FunctionResultCallback_6_4
< false, R, P1, P2, P3, P4, P5,
P6, A1, A2, A3, A4 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_0_5
< true, R, T1, A1, A2, A3, A4,
A5 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(A1, A2, A3, A4, A5) const)
 namespace
template<class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_0_5
< false, R, T1, A1, A2, A3, A4,
A5 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(A1, A2, A3, A4, A5) const)
template<class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_0_5
< true, R, T1, A1, A2, A3, A4,
A5 >::base * 		NewCallback (T1 *obj, R(T2::*member)(A1, A2, A3, A4, A5))
 namespace
template<class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_0_5
< false, R, T1, A1, A2, A3, A4,
A5 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(A1, A2, A3, A4, A5))
template<class R, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_0_5
< true, R, A1, A2, A3, A4, A5 >
::base * 		NewCallback (R(*function)(A1, A2, A3, A4, A5))
 namespace
template<class R, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_0_5
< false, R, A1, A2, A3, A4, A5 >
::base * 		NewPermanentCallback (R(*function)(A1, A2, A3, A4, A5))
template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_1_5
< true, R, T1, P1, A1, A2, A3,
A4, A5 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, A1, A2, A3, A4, A5) const, P1 p1)
 namespace
template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_1_5
< false, R, T1, P1, A1, A2, A3,
A4, A5 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, A1, A2, A3, A4, A5) const, P1 p1)
template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_1_5
< true, R, T1, P1, A1, A2, A3,
A4, A5 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, A1, A2, A3, A4, A5), P1 p1)
 namespace
template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_1_5
< false, R, T1, P1, A1, A2, A3,
A4, A5 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, A1, A2, A3, A4, A5), P1 p1)
template<class R, class P1, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_1_5
< true, R, P1, A1, A2, A3, A4,
A5 >::base * 		NewCallback (R(*function)(P1, A1, A2, A3, A4, A5), P1 p1)
 namespace
template<class R, class P1, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_1_5
< false, R, P1, A1, A2, A3, A4,
A5 >::base * 		NewPermanentCallback (R(*function)(P1, A1, A2, A3, A4, A5), P1 p1)
template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_2_5
< true, R, T1, P1, P2, A1, A2,
A3, A4, A5 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, A1, A2, A3, A4, A5) const, P1 p1, P2 p2)
 namespace
template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_2_5
< false, R, T1, P1, P2, A1, A2,
A3, A4, A5 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, A1, A2, A3, A4, A5) const, P1 p1, P2 p2)
template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_2_5
< true, R, T1, P1, P2, A1, A2,
A3, A4, A5 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, A1, A2, A3, A4, A5), P1 p1, P2 p2)
 namespace
template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_2_5
< false, R, T1, P1, P2, A1, A2,
A3, A4, A5 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, A1, A2, A3, A4, A5), P1 p1, P2 p2)
template<class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_2_5
< true, R, P1, P2, A1, A2, A3,
A4, A5 >::base * 		NewCallback (R(*function)(P1, P2, A1, A2, A3, A4, A5), P1 p1, P2 p2)
 namespace
template<class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_2_5
< false, R, P1, P2, A1, A2, A3,
A4, A5 >::base * 		NewPermanentCallback (R(*function)(P1, P2, A1, A2, A3, A4, A5), P1 p1, P2 p2)
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_3_5
< true, R, T1, P1, P2, P3, A1,
A2, A3, A4, A5 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2, A3, A4, A5) const, P1 p1, P2 p2, P3 p3)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_3_5
< false, R, T1, P1, P2, P3, A1,
A2, A3, A4, A5 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2, A3, A4, A5) const, P1 p1, P2 p2, P3 p3)
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_3_5
< true, R, T1, P1, P2, P3, A1,
A2, A3, A4, A5 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_3_5
< false, R, T1, P1, P2, P3, A1,
A2, A3, A4, A5 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3)
template<class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_3_5
< true, R, P1, P2, P3, A1, A2,
A3, A4, A5 >::base * 		NewCallback (R(*function)(P1, P2, P3, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3)
 namespace
template<class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_3_5
< false, R, P1, P2, P3, A1, A2,
A3, A4, A5 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_4_5
< true, R, T1, P1, P2, P3, P4,
A1, A2, A3, A4, A5 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4, A5) const, P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_4_5
< false, R, T1, P1, P2, P3, P4,
A1, A2, A3, A4, A5 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4, A5) const, P1 p1, P2 p2, P3 p3, P4 p4)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_4_5
< true, R, T1, P1, P2, P3, P4,
A1, A2, A3, A4, A5 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_4_5
< false, R, T1, P1, P2, P3, P4,
A1, A2, A3, A4, A5 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3, P4 p4)
template<class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_4_5
< true, R, P1, P2, P3, P4, A1,
A2, A3, A4, A5 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3, P4 p4)
 namespace
template<class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_4_5
< false, R, P1, P2, P3, P4, A1,
A2, A3, A4, A5 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3, P4 p4)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_5_5
< true, R, T1, P1, P2, P3, P4,
P5, A1, A2, A3, A4, A5 >::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_5_5
< false, R, T1, P1, P2, P3, P4,
P5, A1, A2, A3, A4, A5 >::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_5_5
< true, R, T1, P1, P2, P3, P4,
P5, A1, A2, A3, A4, A5 >::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_5_5
< false, R, T1, P1, P2, P3, P4,
P5, A1, A2, A3, A4, A5 >::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_5_5
< true, R, P1, P2, P3, P4, P5,
A1, A2, A3, A4, A5 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
 namespace
template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_5_5
< false, R, P1, P2, P3, P4, P5,
A1, A2, A3, A4, A5 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_6_5
< true, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2, A3, A4, A5 >
::base * 		NewCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_6_5
< false, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2, A3, A4, A5 >
::base * 		NewPermanentCallback (const T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5) const, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_6_5
< true, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2, A3, A4, A5 >
::base * 		NewCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_6_5
< false, R, T1, P1, P2, P3, P4,
P5, P6, A1, A2, A3, A4, A5 >
::base * 		NewPermanentCallback (T1 *obj, R(T2::*member)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_6_5
< true, R, P1, P2, P3, P4, P5,
P6, A1, A2, A3, A4, A5 >::base * 		NewCallback (R(*function)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 namespace
template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_6_5
< false, R, P1, P2, P3, P4, P5,
P6, A1, A2, A3, A4, A5 >::base * 		NewPermanentCallback (R(*function)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
 OR_TOOLS_BASE_CALLBACK_H_.

Function Documentation

template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_6_5<true,R,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>::base* NewCallback ( R(*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 12016 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_6_5<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 11918 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_6_5<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 11815 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_5_5<true,R,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>::base* NewCallback ( R(*)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 11715 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_5_5<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 11619 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_5_5<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 11518 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_4_5<true,R,P1,P2,P3,P4,A1,A2,A3,A4,A5>::base* NewCallback ( R(*)(P1, P2, P3, P4, A1, A2, A3, A4, A5)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 11420 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_4_5<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2, A3, A4, A5)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 11326 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_4_5<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2, A3, A4, A5) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 11227 of file callback.h.

template<class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_3_5<true,R,P1,P2,P3,A1,A2,A3,A4,A5>::base* NewCallback ( R(*)(P1, P2, P3, A1, A2, A3, A4, A5)  function,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 11131 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_3_5<true,R,T1,P1,P2,P3,A1,A2,A3,A4,A5>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2, A3, A4, A5)  member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 11039 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_3_5<true,R,T1,P1,P2,P3,A1,A2,A3,A4,A5>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2, A3, A4, A5) const   member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 10942 of file callback.h.

template<class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_2_5<true,R,P1,P2,A1,A2,A3,A4,A5>::base* NewCallback ( R(*)(P1, P2, A1, A2, A3, A4, A5)  function,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 10848 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_2_5<true,R,T1,P1,P2,A1,A2,A3,A4,A5>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, A1, A2, A3, A4, A5)  member,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 10758 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_2_5<true,R,T1,P1,P2,A1,A2,A3,A4,A5>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, A1, A2, A3, A4, A5) const   member,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 10663 of file callback.h.

template<class R, class P1, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_1_5<true,R,P1,A1,A2,A3,A4,A5>::base* NewCallback ( R(*)(P1, A1, A2, A3, A4, A5)  function,
P1  p1 
) [inline]

namespace

Definition at line 10571 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_1_5<true,R,T1,P1,A1,A2,A3,A4,A5>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, A1, A2, A3, A4, A5)  member,
P1  p1 
) [inline]

namespace

Definition at line 10483 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_1_5<true,R,T1,P1,A1,A2,A3,A4,A5>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, A1, A2, A3, A4, A5) const   member,
P1  p1 
) [inline]

namespace

Definition at line 10390 of file callback.h.

template<class R, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_0_5<true,R,A1,A2,A3,A4,A5>::base* NewCallback ( R(*)(A1, A2, A3, A4, A5)  function  )  [inline]

namespace

Definition at line 10300 of file callback.h.

template<class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_0_5<true,R,T1,A1,A2,A3,A4,A5>::base* NewCallback ( T1 *  obj,
R(T2::*)(A1, A2, A3, A4, A5)  member 
) [inline]

namespace

Definition at line 10214 of file callback.h.

template<class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_0_5<true,R,T1,A1,A2,A3,A4,A5>::base* NewCallback ( const T1 *  obj,
R(T2::*)(A1, A2, A3, A4, A5) const   member 
) [inline]

namespace

Definition at line 10123 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
_FunctionResultCallback_6_4<true,R,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>::base* NewCallback ( R(*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 10035 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
_MemberResultCallback_6_4<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 9937 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_6_4<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 9834 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
_FunctionResultCallback_5_4<true,R,P1,P2,P3,P4,P5,A1,A2,A3,A4>::base* NewCallback ( R(*)(P1, P2, P3, P4, P5, A1, A2, A3, A4)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 9734 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
_MemberResultCallback_5_4<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 9638 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_5_4<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 9537 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
_FunctionResultCallback_4_4<true,R,P1,P2,P3,P4,A1,A2,A3,A4>::base* NewCallback ( R(*)(P1, P2, P3, P4, A1, A2, A3, A4)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 9439 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
_MemberResultCallback_4_4<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2, A3, A4)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 9345 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_4_4<true,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2, A3, A4) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 9246 of file callback.h.

template<class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
_FunctionResultCallback_3_4<true,R,P1,P2,P3,A1,A2,A3,A4>::base* NewCallback ( R(*)(P1, P2, P3, A1, A2, A3, A4)  function,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 9150 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
_MemberResultCallback_3_4<true,R,T1,P1,P2,P3,A1,A2,A3,A4>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2, A3, A4)  member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 9058 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_3_4<true,R,T1,P1,P2,P3,A1,A2,A3,A4>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2, A3, A4) const   member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 8961 of file callback.h.

template<class R, class P1, class P2, class A1, class A2, class A3, class A4>
_FunctionResultCallback_2_4<true,R,P1,P2,A1,A2,A3,A4>::base* NewCallback ( R(*)(P1, P2, A1, A2, A3, A4)  function,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 8867 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
_MemberResultCallback_2_4<true,R,T1,P1,P2,A1,A2,A3,A4>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, A1, A2, A3, A4)  member,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 8777 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_2_4<true,R,T1,P1,P2,A1,A2,A3,A4>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, A1, A2, A3, A4) const   member,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 8682 of file callback.h.

template<class R, class P1, class A1, class A2, class A3, class A4>
_FunctionResultCallback_1_4<true,R,P1,A1,A2,A3,A4>::base* NewCallback ( R(*)(P1, A1, A2, A3, A4)  function,
P1  p1 
) [inline]

namespace

Definition at line 8590 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
_MemberResultCallback_1_4<true,R,T1,P1,A1,A2,A3,A4>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, A1, A2, A3, A4)  member,
P1  p1 
) [inline]

namespace

Definition at line 8502 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_1_4<true,R,T1,P1,A1,A2,A3,A4>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, A1, A2, A3, A4) const   member,
P1  p1 
) [inline]

namespace

Definition at line 8409 of file callback.h.

template<class R, class A1, class A2, class A3, class A4>
_FunctionResultCallback_0_4<true,R,A1,A2,A3,A4>::base* NewCallback ( R(*)(A1, A2, A3, A4)  function  )  [inline]

namespace

Definition at line 8319 of file callback.h.

template<class T1, class T2, class R, class A1, class A2, class A3, class A4>
_MemberResultCallback_0_4<true,R,T1,A1,A2,A3,A4>::base* NewCallback ( T1 *  obj,
R(T2::*)(A1, A2, A3, A4)  member 
) [inline]

namespace

Definition at line 8233 of file callback.h.

template<class T1, class T2, class R, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_0_4<true,R,T1,A1,A2,A3,A4>::base* NewCallback ( const T1 *  obj,
R(T2::*)(A1, A2, A3, A4) const   member 
) [inline]

namespace

Definition at line 8142 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
_FunctionResultCallback_6_3<true,R,P1,P2,P3,P4,P5,P6,A1,A2,A3>::base* NewCallback ( R(*)(P1, P2, P3, P4, P5, P6, A1, A2, A3)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 8054 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
_MemberResultCallback_6_3<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 7956 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
_ConstMemberResultCallback_6_3<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 7853 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
_FunctionResultCallback_5_3<true,R,P1,P2,P3,P4,P5,A1,A2,A3>::base* NewCallback ( R(*)(P1, P2, P3, P4, P5, A1, A2, A3)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 7753 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
_MemberResultCallback_5_3<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2, A3)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 7657 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
_ConstMemberResultCallback_5_3<true,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2, A3) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 7556 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
_FunctionResultCallback_4_3<true,R,P1,P2,P3,P4,A1,A2,A3>::base* NewCallback ( R(*)(P1, P2, P3, P4, A1, A2, A3)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 7458 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
_MemberResultCallback_4_3<true,R,T1,P1,P2,P3,P4,A1,A2,A3>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2, A3)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 7364 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
_ConstMemberResultCallback_4_3<true,R,T1,P1,P2,P3,P4,A1,A2,A3>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2, A3) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 7265 of file callback.h.

template<class R, class P1, class P2, class P3, class A1, class A2, class A3>
_FunctionResultCallback_3_3<true,R,P1,P2,P3,A1,A2,A3>::base* NewCallback ( R(*)(P1, P2, P3, A1, A2, A3)  function,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 7169 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
_MemberResultCallback_3_3<true,R,T1,P1,P2,P3,A1,A2,A3>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2, A3)  member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 7077 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
_ConstMemberResultCallback_3_3<true,R,T1,P1,P2,P3,A1,A2,A3>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2, A3) const   member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 6980 of file callback.h.

template<class R, class P1, class P2, class A1, class A2, class A3>
_FunctionResultCallback_2_3<true,R,P1,P2,A1,A2,A3>::base* NewCallback ( R(*)(P1, P2, A1, A2, A3)  function,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 6886 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
_MemberResultCallback_2_3<true,R,T1,P1,P2,A1,A2,A3>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, A1, A2, A3)  member,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 6796 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
_ConstMemberResultCallback_2_3<true,R,T1,P1,P2,A1,A2,A3>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, A1, A2, A3) const   member,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 6701 of file callback.h.

template<class R, class P1, class A1, class A2, class A3>
_FunctionResultCallback_1_3<true,R,P1,A1,A2,A3>::base* NewCallback ( R(*)(P1, A1, A2, A3)  function,
P1  p1 
) [inline]

namespace

Definition at line 6609 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2, class A3>
_MemberResultCallback_1_3<true,R,T1,P1,A1,A2,A3>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, A1, A2, A3)  member,
P1  p1 
) [inline]

namespace

Definition at line 6521 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2, class A3>
_ConstMemberResultCallback_1_3<true,R,T1,P1,A1,A2,A3>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, A1, A2, A3) const   member,
P1  p1 
) [inline]

namespace

Definition at line 6428 of file callback.h.

template<class R, class A1, class A2, class A3>
_FunctionResultCallback_0_3<true,R,A1,A2,A3>::base* NewCallback ( R(*)(A1, A2, A3)  function  )  [inline]

namespace

Definition at line 6338 of file callback.h.

template<class T1, class T2, class R, class A1, class A2, class A3>
_MemberResultCallback_0_3<true,R,T1,A1,A2,A3>::base* NewCallback ( T1 *  obj,
R(T2::*)(A1, A2, A3)  member 
) [inline]

namespace

Definition at line 6252 of file callback.h.

template<class T1, class T2, class R, class A1, class A2, class A3>
_ConstMemberResultCallback_0_3<true,R,T1,A1,A2,A3>::base* NewCallback ( const T1 *  obj,
R(T2::*)(A1, A2, A3) const   member 
) [inline]

namespace

Definition at line 6161 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
_FunctionResultCallback_6_2<true,R,P1,P2,P3,P4,P5,P6,A1,A2>::base* NewCallback ( R(*)(P1, P2, P3, P4, P5, P6, A1, A2)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 6073 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
_MemberResultCallback_6_2<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 5975 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
_ConstMemberResultCallback_6_2<true,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 5872 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
_FunctionResultCallback_5_2<true,R,P1,P2,P3,P4,P5,A1,A2>::base* NewCallback ( R(*)(P1, P2, P3, P4, P5, A1, A2)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 5772 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
_MemberResultCallback_5_2<true,R,T1,P1,P2,P3,P4,P5,A1,A2>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 5676 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
_ConstMemberResultCallback_5_2<true,R,T1,P1,P2,P3,P4,P5,A1,A2>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 5575 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class A1, class A2>
_FunctionResultCallback_4_2<true,R,P1,P2,P3,P4,A1,A2>::base* NewCallback ( R(*)(P1, P2, P3, P4, A1, A2)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 5477 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
_MemberResultCallback_4_2<true,R,T1,P1,P2,P3,P4,A1,A2>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 5383 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
_ConstMemberResultCallback_4_2<true,R,T1,P1,P2,P3,P4,A1,A2>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 5284 of file callback.h.

template<class R, class P1, class P2, class P3, class A1, class A2>
_FunctionResultCallback_3_2<true,R,P1,P2,P3,A1,A2>::base* NewCallback ( R(*)(P1, P2, P3, A1, A2)  function,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 5188 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
_MemberResultCallback_3_2<true,R,T1,P1,P2,P3,A1,A2>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2)  member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 5096 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
_ConstMemberResultCallback_3_2<true,R,T1,P1,P2,P3,A1,A2>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2) const   member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 4999 of file callback.h.

template<class R, class P1, class P2, class A1, class A2>
_FunctionResultCallback_2_2<true,R,P1,P2,A1,A2>::base* NewCallback ( R(*)(P1, P2, A1, A2)  function,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 4905 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2>
_MemberResultCallback_2_2<true,R,T1,P1,P2,A1,A2>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, A1, A2)  member,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 4815 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2>
_ConstMemberResultCallback_2_2<true,R,T1,P1,P2,A1,A2>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, A1, A2) const   member,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 4720 of file callback.h.

template<class R, class P1, class A1, class A2>
_FunctionResultCallback_1_2<true,R,P1,A1,A2>::base* NewCallback ( R(*)(P1, A1, A2)  function,
P1  p1 
) [inline]

namespace

Definition at line 4628 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2>
_MemberResultCallback_1_2<true,R,T1,P1,A1,A2>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, A1, A2)  member,
P1  p1 
) [inline]

namespace

Definition at line 4540 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2>
_ConstMemberResultCallback_1_2<true,R,T1,P1,A1,A2>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, A1, A2) const   member,
P1  p1 
) [inline]

namespace

Definition at line 4447 of file callback.h.

template<class R, class A1, class A2>
_FunctionResultCallback_0_2<true,R,A1,A2>::base* NewCallback ( R(*)(A1, A2)  function  )  [inline]

namespace

Definition at line 4357 of file callback.h.

template<class T1, class T2, class R, class A1, class A2>
_MemberResultCallback_0_2<true,R,T1,A1,A2>::base* NewCallback ( T1 *  obj,
R(T2::*)(A1, A2)  member 
) [inline]

namespace

Definition at line 4271 of file callback.h.

template<class T1, class T2, class R, class A1, class A2>
_ConstMemberResultCallback_0_2<true,R,T1,A1,A2>::base* NewCallback ( const T1 *  obj,
R(T2::*)(A1, A2) const   member 
) [inline]

namespace

Definition at line 4180 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
_FunctionResultCallback_6_1<true,R,P1,P2,P3,P4,P5,P6,A1>::base* NewCallback ( R(*)(P1, P2, P3, P4, P5, P6, A1)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 4092 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
_MemberResultCallback_6_1<true,R,T1,P1,P2,P3,P4,P5,P6,A1>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 3994 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
_ConstMemberResultCallback_6_1<true,R,T1,P1,P2,P3,P4,P5,P6,A1>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 3891 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class A1>
_FunctionResultCallback_5_1<true,R,P1,P2,P3,P4,P5,A1>::base* NewCallback ( R(*)(P1, P2, P3, P4, P5, A1)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 3791 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
_MemberResultCallback_5_1<true,R,T1,P1,P2,P3,P4,P5,A1>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 3695 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
_ConstMemberResultCallback_5_1<true,R,T1,P1,P2,P3,P4,P5,A1>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 3594 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class A1>
_FunctionResultCallback_4_1<true,R,P1,P2,P3,P4,A1>::base* NewCallback ( R(*)(P1, P2, P3, P4, A1)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 3496 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
_MemberResultCallback_4_1<true,R,T1,P1,P2,P3,P4,A1>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 3402 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
_ConstMemberResultCallback_4_1<true,R,T1,P1,P2,P3,P4,A1>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 3303 of file callback.h.

template<class R, class P1, class P2, class P3, class A1>
_FunctionResultCallback_3_1<true,R,P1,P2,P3,A1>::base* NewCallback ( R(*)(P1, P2, P3, A1)  function,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 3207 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1>
_MemberResultCallback_3_1<true,R,T1,P1,P2,P3,A1>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, A1)  member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 3115 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1>
_ConstMemberResultCallback_3_1<true,R,T1,P1,P2,P3,A1>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, A1) const   member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 3018 of file callback.h.

template<class R, class P1, class P2, class A1>
_FunctionResultCallback_2_1<true,R,P1,P2,A1>::base* NewCallback ( R(*)(P1, P2, A1)  function,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 2924 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1>
_MemberResultCallback_2_1<true,R,T1,P1,P2,A1>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, A1)  member,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 2834 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1>
_ConstMemberResultCallback_2_1<true,R,T1,P1,P2,A1>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, A1) const   member,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 2739 of file callback.h.

template<class R, class P1, class A1>
_FunctionResultCallback_1_1<true,R,P1,A1>::base* NewCallback ( R(*)(P1, A1)  function,
P1  p1 
) [inline]

namespace

Definition at line 2647 of file callback.h.

template<class T1, class T2, class R, class P1, class A1>
_MemberResultCallback_1_1<true,R,T1,P1,A1>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, A1)  member,
P1  p1 
) [inline]

namespace

Definition at line 2559 of file callback.h.

template<class T1, class T2, class R, class P1, class A1>
_ConstMemberResultCallback_1_1<true,R,T1,P1,A1>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, A1) const   member,
P1  p1 
) [inline]

namespace

Definition at line 2466 of file callback.h.

template<class R, class A1>
_FunctionResultCallback_0_1<true,R,A1>::base* NewCallback ( R(*)(A1)  function  )  [inline]

namespace

Definition at line 2376 of file callback.h.

template<class T1, class T2, class R, class A1>
_MemberResultCallback_0_1<true,R,T1,A1>::base* NewCallback ( T1 *  obj,
R(T2::*)(A1)  member 
) [inline]

namespace

Definition at line 2290 of file callback.h.

template<class T1, class T2, class R, class A1>
_ConstMemberResultCallback_0_1<true,R,T1,A1>::base* NewCallback ( const T1 *  obj,
R(T2::*)(A1) const   member 
) [inline]

namespace

Definition at line 2199 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class P6>
_FunctionResultCallback_6_0<true,R,P1,P2,P3,P4,P5,P6>::base* NewCallback ( R(*)(P1, P2, P3, P4, P5, P6)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 2111 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
_MemberResultCallback_6_0<true,R,T1,P1,P2,P3,P4,P5,P6>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 2013 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
_ConstMemberResultCallback_6_0<true,R,T1,P1,P2,P3,P4,P5,P6>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

namespace

Definition at line 1910 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5>
_FunctionResultCallback_5_0<true,R,P1,P2,P3,P4,P5>::base* NewCallback ( R(*)(P1, P2, P3, P4, P5)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 1810 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
_MemberResultCallback_5_0<true,R,T1,P1,P2,P3,P4,P5>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 1714 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
_ConstMemberResultCallback_5_0<true,R,T1,P1,P2,P3,P4,P5>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

namespace

Definition at line 1613 of file callback.h.

template<class R, class P1, class P2, class P3, class P4>
_FunctionResultCallback_4_0<true,R,P1,P2,P3,P4>::base* NewCallback ( R(*)(P1, P2, P3, P4)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 1515 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4>
_MemberResultCallback_4_0<true,R,T1,P1,P2,P3,P4>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 1421 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4>
_ConstMemberResultCallback_4_0<true,R,T1,P1,P2,P3,P4>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

namespace

Definition at line 1322 of file callback.h.

template<class R, class P1, class P2, class P3>
_FunctionResultCallback_3_0<true,R,P1,P2,P3>::base* NewCallback ( R(*)(P1, P2, P3)  function,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 1226 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3>
_MemberResultCallback_3_0<true,R,T1,P1,P2,P3>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3)  member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 1134 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3>
_ConstMemberResultCallback_3_0<true,R,T1,P1,P2,P3>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3) const   member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

namespace

Definition at line 1037 of file callback.h.

template<class R, class P1, class P2>
_FunctionResultCallback_2_0<true,R,P1,P2>::base* NewCallback ( R(*)(P1, P2)  function,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 943 of file callback.h.

template<class T1, class T2, class R, class P1, class P2>
_MemberResultCallback_2_0<true,R,T1,P1,P2>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1, P2)  member,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 853 of file callback.h.

template<class T1, class T2, class R, class P1, class P2>
_ConstMemberResultCallback_2_0<true,R,T1,P1,P2>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1, P2) const   member,
P1  p1,
P2  p2 
) [inline]

namespace

Definition at line 758 of file callback.h.

template<class R, class P1>
_FunctionResultCallback_1_0<true,R,P1>::base* NewCallback ( R(*)(P1)  function,
P1  p1 
) [inline]

namespace

Definition at line 666 of file callback.h.

template<class T1, class T2, class R, class P1>
_MemberResultCallback_1_0<true,R,T1,P1>::base* NewCallback ( T1 *  obj,
R(T2::*)(P1)  member,
P1  p1 
) [inline]

namespace

Definition at line 578 of file callback.h.

template<class T1, class T2, class R, class P1>
_ConstMemberResultCallback_1_0<true,R,T1,P1>::base* NewCallback ( const T1 *  obj,
R(T2::*)(P1) const   member,
P1  p1 
) [inline]

namespace

Definition at line 484 of file callback.h.

template<class R>
_FunctionResultCallback_0_0<true,R>::base* NewCallback ( R(*)()  function  )  [inline]

namespace

Definition at line 393 of file callback.h.

template<class T1, class T2, class R>
_MemberResultCallback_0_0<true,R,T1>::base* @6::NewCallback ( T1 *  obj,
R(T2::*)()  member 
) [inline, static]

Definition at line 307 of file callback.h.

template<class T1, class T2, class R>
_ConstMemberResultCallback_0_0<true,R,T1>::base* @6::NewCallback ( const T1 *  obj,
R(T2::*)() const   member 
) [inline, static]

Definition at line 217 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_6_5<false,R,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

OR_TOOLS_BASE_CALLBACK_H_.

Definition at line 12022 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_6_5<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 11926 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_6_5<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4, A5) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 11823 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_5_5<false,R,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 11721 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_5_5<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 11627 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_5_5<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4, A5) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 11526 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_4_5<false,R,P1,P2,P3,P4,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, A1, A2, A3, A4, A5)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 11426 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_4_5<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2, A3, A4, A5)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 11334 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_4_5<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2, A3, A4, A5) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 11235 of file callback.h.

template<class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_3_5<false,R,P1,P2,P3,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( R(*)(P1, P2, P3, A1, A2, A3, A4, A5)  function,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 11137 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_3_5<false,R,T1,P1,P2,P3,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2, A3, A4, A5)  member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 11047 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_3_5<false,R,T1,P1,P2,P3,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2, A3, A4, A5) const   member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 10950 of file callback.h.

template<class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_2_5<false,R,P1,P2,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( R(*)(P1, P2, A1, A2, A3, A4, A5)  function,
P1  p1,
P2  p2 
) [inline]

Definition at line 10854 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_2_5<false,R,T1,P1,P2,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, A1, A2, A3, A4, A5)  member,
P1  p1,
P2  p2 
) [inline]

Definition at line 10766 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_2_5<false,R,T1,P1,P2,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, A1, A2, A3, A4, A5) const   member,
P1  p1,
P2  p2 
) [inline]

Definition at line 10671 of file callback.h.

template<class R, class P1, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_1_5<false,R,P1,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( R(*)(P1, A1, A2, A3, A4, A5)  function,
P1  p1 
) [inline]

Definition at line 10577 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_1_5<false,R,T1,P1,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, A1, A2, A3, A4, A5)  member,
P1  p1 
) [inline]

Definition at line 10491 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_1_5<false,R,T1,P1,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, A1, A2, A3, A4, A5) const   member,
P1  p1 
) [inline]

Definition at line 10398 of file callback.h.

template<class R, class A1, class A2, class A3, class A4, class A5>
_FunctionResultCallback_0_5<false,R,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( R(*)(A1, A2, A3, A4, A5)  function  )  [inline]

Definition at line 10306 of file callback.h.

template<class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
_MemberResultCallback_0_5<false,R,T1,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(A1, A2, A3, A4, A5)  member 
) [inline]

Definition at line 10222 of file callback.h.

template<class T1, class T2, class R, class A1, class A2, class A3, class A4, class A5>
_ConstMemberResultCallback_0_5<false,R,T1,A1,A2,A3,A4,A5>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(A1, A2, A3, A4, A5) const   member 
) [inline]

Definition at line 10131 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
_FunctionResultCallback_6_4<false,R,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 10041 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
_MemberResultCallback_6_4<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 9945 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_6_4<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3,A4>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3, A4) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 9842 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
_FunctionResultCallback_5_4<false,R,P1,P2,P3,P4,P5,A1,A2,A3,A4>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, P5, A1, A2, A3, A4)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 9740 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
_MemberResultCallback_5_4<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 9646 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_5_4<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3,A4>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2, A3, A4) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 9545 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
_FunctionResultCallback_4_4<false,R,P1,P2,P3,P4,A1,A2,A3,A4>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, A1, A2, A3, A4)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 9445 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
_MemberResultCallback_4_4<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2, A3, A4)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 9353 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_4_4<false,R,T1,P1,P2,P3,P4,A1,A2,A3,A4>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2, A3, A4) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 9254 of file callback.h.

template<class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
_FunctionResultCallback_3_4<false,R,P1,P2,P3,A1,A2,A3,A4>::base* NewPermanentCallback ( R(*)(P1, P2, P3, A1, A2, A3, A4)  function,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 9156 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
_MemberResultCallback_3_4<false,R,T1,P1,P2,P3,A1,A2,A3,A4>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2, A3, A4)  member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 9066 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_3_4<false,R,T1,P1,P2,P3,A1,A2,A3,A4>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2, A3, A4) const   member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 8969 of file callback.h.

template<class R, class P1, class P2, class A1, class A2, class A3, class A4>
_FunctionResultCallback_2_4<false,R,P1,P2,A1,A2,A3,A4>::base* NewPermanentCallback ( R(*)(P1, P2, A1, A2, A3, A4)  function,
P1  p1,
P2  p2 
) [inline]

Definition at line 8873 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
_MemberResultCallback_2_4<false,R,T1,P1,P2,A1,A2,A3,A4>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, A1, A2, A3, A4)  member,
P1  p1,
P2  p2 
) [inline]

Definition at line 8785 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_2_4<false,R,T1,P1,P2,A1,A2,A3,A4>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, A1, A2, A3, A4) const   member,
P1  p1,
P2  p2 
) [inline]

Definition at line 8690 of file callback.h.

template<class R, class P1, class A1, class A2, class A3, class A4>
_FunctionResultCallback_1_4<false,R,P1,A1,A2,A3,A4>::base* NewPermanentCallback ( R(*)(P1, A1, A2, A3, A4)  function,
P1  p1 
) [inline]

Definition at line 8596 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
_MemberResultCallback_1_4<false,R,T1,P1,A1,A2,A3,A4>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, A1, A2, A3, A4)  member,
P1  p1 
) [inline]

Definition at line 8510 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_1_4<false,R,T1,P1,A1,A2,A3,A4>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, A1, A2, A3, A4) const   member,
P1  p1 
) [inline]

Definition at line 8417 of file callback.h.

template<class R, class A1, class A2, class A3, class A4>
_FunctionResultCallback_0_4<false,R,A1,A2,A3,A4>::base* NewPermanentCallback ( R(*)(A1, A2, A3, A4)  function  )  [inline]

Definition at line 8325 of file callback.h.

template<class T1, class T2, class R, class A1, class A2, class A3, class A4>
_MemberResultCallback_0_4<false,R,T1,A1,A2,A3,A4>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(A1, A2, A3, A4)  member 
) [inline]

Definition at line 8241 of file callback.h.

template<class T1, class T2, class R, class A1, class A2, class A3, class A4>
_ConstMemberResultCallback_0_4<false,R,T1,A1,A2,A3,A4>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(A1, A2, A3, A4) const   member 
) [inline]

Definition at line 8150 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
_FunctionResultCallback_6_3<false,R,P1,P2,P3,P4,P5,P6,A1,A2,A3>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, P5, P6, A1, A2, A3)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 8060 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
_MemberResultCallback_6_3<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 7964 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2, class A3>
_ConstMemberResultCallback_6_3<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2,A3>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2, A3) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 7861 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
_FunctionResultCallback_5_3<false,R,P1,P2,P3,P4,P5,A1,A2,A3>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, P5, A1, A2, A3)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 7759 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
_MemberResultCallback_5_3<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2, A3)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 7665 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2, class A3>
_ConstMemberResultCallback_5_3<false,R,T1,P1,P2,P3,P4,P5,A1,A2,A3>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2, A3) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 7564 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
_FunctionResultCallback_4_3<false,R,P1,P2,P3,P4,A1,A2,A3>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, A1, A2, A3)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 7464 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
_MemberResultCallback_4_3<false,R,T1,P1,P2,P3,P4,A1,A2,A3>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2, A3)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 7372 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2, class A3>
_ConstMemberResultCallback_4_3<false,R,T1,P1,P2,P3,P4,A1,A2,A3>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2, A3) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 7273 of file callback.h.

template<class R, class P1, class P2, class P3, class A1, class A2, class A3>
_FunctionResultCallback_3_3<false,R,P1,P2,P3,A1,A2,A3>::base* NewPermanentCallback ( R(*)(P1, P2, P3, A1, A2, A3)  function,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 7175 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
_MemberResultCallback_3_3<false,R,T1,P1,P2,P3,A1,A2,A3>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2, A3)  member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 7085 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2, class A3>
_ConstMemberResultCallback_3_3<false,R,T1,P1,P2,P3,A1,A2,A3>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2, A3) const   member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 6988 of file callback.h.

template<class R, class P1, class P2, class A1, class A2, class A3>
_FunctionResultCallback_2_3<false,R,P1,P2,A1,A2,A3>::base* NewPermanentCallback ( R(*)(P1, P2, A1, A2, A3)  function,
P1  p1,
P2  p2 
) [inline]

Definition at line 6892 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
_MemberResultCallback_2_3<false,R,T1,P1,P2,A1,A2,A3>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, A1, A2, A3)  member,
P1  p1,
P2  p2 
) [inline]

Definition at line 6804 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2, class A3>
_ConstMemberResultCallback_2_3<false,R,T1,P1,P2,A1,A2,A3>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, A1, A2, A3) const   member,
P1  p1,
P2  p2 
) [inline]

Definition at line 6709 of file callback.h.

template<class R, class P1, class A1, class A2, class A3>
_FunctionResultCallback_1_3<false,R,P1,A1,A2,A3>::base* NewPermanentCallback ( R(*)(P1, A1, A2, A3)  function,
P1  p1 
) [inline]

Definition at line 6615 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2, class A3>
_MemberResultCallback_1_3<false,R,T1,P1,A1,A2,A3>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, A1, A2, A3)  member,
P1  p1 
) [inline]

Definition at line 6529 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2, class A3>
_ConstMemberResultCallback_1_3<false,R,T1,P1,A1,A2,A3>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, A1, A2, A3) const   member,
P1  p1 
) [inline]

Definition at line 6436 of file callback.h.

template<class R, class A1, class A2, class A3>
_FunctionResultCallback_0_3<false,R,A1,A2,A3>::base* NewPermanentCallback ( R(*)(A1, A2, A3)  function  )  [inline]

Definition at line 6344 of file callback.h.

template<class T1, class T2, class R, class A1, class A2, class A3>
_MemberResultCallback_0_3<false,R,T1,A1,A2,A3>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(A1, A2, A3)  member 
) [inline]

Definition at line 6260 of file callback.h.

template<class T1, class T2, class R, class A1, class A2, class A3>
_ConstMemberResultCallback_0_3<false,R,T1,A1,A2,A3>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(A1, A2, A3) const   member 
) [inline]

Definition at line 6169 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
_FunctionResultCallback_6_2<false,R,P1,P2,P3,P4,P5,P6,A1,A2>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, P5, P6, A1, A2)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 6079 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
_MemberResultCallback_6_2<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 5983 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1, class A2>
_ConstMemberResultCallback_6_2<false,R,T1,P1,P2,P3,P4,P5,P6,A1,A2>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1, A2) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 5880 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
_FunctionResultCallback_5_2<false,R,P1,P2,P3,P4,P5,A1,A2>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, P5, A1, A2)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 5778 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
_MemberResultCallback_5_2<false,R,T1,P1,P2,P3,P4,P5,A1,A2>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 5684 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1, class A2>
_ConstMemberResultCallback_5_2<false,R,T1,P1,P2,P3,P4,P5,A1,A2>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1, A2) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 5583 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class A1, class A2>
_FunctionResultCallback_4_2<false,R,P1,P2,P3,P4,A1,A2>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, A1, A2)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 5483 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
_MemberResultCallback_4_2<false,R,T1,P1,P2,P3,P4,A1,A2>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 5391 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1, class A2>
_ConstMemberResultCallback_4_2<false,R,T1,P1,P2,P3,P4,A1,A2>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1, A2) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 5292 of file callback.h.

template<class R, class P1, class P2, class P3, class A1, class A2>
_FunctionResultCallback_3_2<false,R,P1,P2,P3,A1,A2>::base* NewPermanentCallback ( R(*)(P1, P2, P3, A1, A2)  function,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 5194 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
_MemberResultCallback_3_2<false,R,T1,P1,P2,P3,A1,A2>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2)  member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 5104 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1, class A2>
_ConstMemberResultCallback_3_2<false,R,T1,P1,P2,P3,A1,A2>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, A1, A2) const   member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 5007 of file callback.h.

template<class R, class P1, class P2, class A1, class A2>
_FunctionResultCallback_2_2<false,R,P1,P2,A1,A2>::base* NewPermanentCallback ( R(*)(P1, P2, A1, A2)  function,
P1  p1,
P2  p2 
) [inline]

Definition at line 4911 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2>
_MemberResultCallback_2_2<false,R,T1,P1,P2,A1,A2>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, A1, A2)  member,
P1  p1,
P2  p2 
) [inline]

Definition at line 4823 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1, class A2>
_ConstMemberResultCallback_2_2<false,R,T1,P1,P2,A1,A2>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, A1, A2) const   member,
P1  p1,
P2  p2 
) [inline]

Definition at line 4728 of file callback.h.

template<class R, class P1, class A1, class A2>
_FunctionResultCallback_1_2<false,R,P1,A1,A2>::base* NewPermanentCallback ( R(*)(P1, A1, A2)  function,
P1  p1 
) [inline]

Definition at line 4634 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2>
_MemberResultCallback_1_2<false,R,T1,P1,A1,A2>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, A1, A2)  member,
P1  p1 
) [inline]

Definition at line 4548 of file callback.h.

template<class T1, class T2, class R, class P1, class A1, class A2>
_ConstMemberResultCallback_1_2<false,R,T1,P1,A1,A2>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, A1, A2) const   member,
P1  p1 
) [inline]

Definition at line 4455 of file callback.h.

template<class R, class A1, class A2>
_FunctionResultCallback_0_2<false,R,A1,A2>::base* NewPermanentCallback ( R(*)(A1, A2)  function  )  [inline]

Definition at line 4363 of file callback.h.

template<class T1, class T2, class R, class A1, class A2>
_MemberResultCallback_0_2<false,R,T1,A1,A2>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(A1, A2)  member 
) [inline]

Definition at line 4279 of file callback.h.

template<class T1, class T2, class R, class A1, class A2>
_ConstMemberResultCallback_0_2<false,R,T1,A1,A2>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(A1, A2) const   member 
) [inline]

Definition at line 4188 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
_FunctionResultCallback_6_1<false,R,P1,P2,P3,P4,P5,P6,A1>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, P5, P6, A1)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 4098 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
_MemberResultCallback_6_1<false,R,T1,P1,P2,P3,P4,P5,P6,A1>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 4002 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6, class A1>
_ConstMemberResultCallback_6_1<false,R,T1,P1,P2,P3,P4,P5,P6,A1>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6, A1) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 3899 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class A1>
_FunctionResultCallback_5_1<false,R,P1,P2,P3,P4,P5,A1>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, P5, A1)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 3797 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
_MemberResultCallback_5_1<false,R,T1,P1,P2,P3,P4,P5,A1>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 3703 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class A1>
_ConstMemberResultCallback_5_1<false,R,T1,P1,P2,P3,P4,P5,A1>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, A1) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 3602 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class A1>
_FunctionResultCallback_4_1<false,R,P1,P2,P3,P4,A1>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, A1)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 3502 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
_MemberResultCallback_4_1<false,R,T1,P1,P2,P3,P4,A1>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 3410 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class A1>
_ConstMemberResultCallback_4_1<false,R,T1,P1,P2,P3,P4,A1>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, A1) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 3311 of file callback.h.

template<class R, class P1, class P2, class P3, class A1>
_FunctionResultCallback_3_1<false,R,P1,P2,P3,A1>::base* NewPermanentCallback ( R(*)(P1, P2, P3, A1)  function,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 3213 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1>
_MemberResultCallback_3_1<false,R,T1,P1,P2,P3,A1>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, A1)  member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 3123 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class A1>
_ConstMemberResultCallback_3_1<false,R,T1,P1,P2,P3,A1>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, A1) const   member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 3026 of file callback.h.

template<class R, class P1, class P2, class A1>
_FunctionResultCallback_2_1<false,R,P1,P2,A1>::base* NewPermanentCallback ( R(*)(P1, P2, A1)  function,
P1  p1,
P2  p2 
) [inline]

Definition at line 2930 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1>
_MemberResultCallback_2_1<false,R,T1,P1,P2,A1>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, A1)  member,
P1  p1,
P2  p2 
) [inline]

Definition at line 2842 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class A1>
_ConstMemberResultCallback_2_1<false,R,T1,P1,P2,A1>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, A1) const   member,
P1  p1,
P2  p2 
) [inline]

Definition at line 2747 of file callback.h.

template<class R, class P1, class A1>
_FunctionResultCallback_1_1<false,R,P1,A1>::base* NewPermanentCallback ( R(*)(P1, A1)  function,
P1  p1 
) [inline]

Definition at line 2653 of file callback.h.

template<class T1, class T2, class R, class P1, class A1>
_MemberResultCallback_1_1<false,R,T1,P1,A1>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, A1)  member,
P1  p1 
) [inline]

Definition at line 2567 of file callback.h.

template<class T1, class T2, class R, class P1, class A1>
_ConstMemberResultCallback_1_1<false,R,T1,P1,A1>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, A1) const   member,
P1  p1 
) [inline]

Definition at line 2474 of file callback.h.

template<class R, class A1>
_FunctionResultCallback_0_1<false,R,A1>::base* NewPermanentCallback ( R(*)(A1)  function  )  [inline]

Definition at line 2382 of file callback.h.

template<class T1, class T2, class R, class A1>
_MemberResultCallback_0_1<false,R,T1,A1>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(A1)  member 
) [inline]

Definition at line 2298 of file callback.h.

template<class T1, class T2, class R, class A1>
_ConstMemberResultCallback_0_1<false,R,T1,A1>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(A1) const   member 
) [inline]

Definition at line 2207 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5, class P6>
_FunctionResultCallback_6_0<false,R,P1,P2,P3,P4,P5,P6>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, P5, P6)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 2117 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
_MemberResultCallback_6_0<false,R,T1,P1,P2,P3,P4,P5,P6>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 2021 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5, class P6>
_ConstMemberResultCallback_6_0<false,R,T1,P1,P2,P3,P4,P5,P6>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5, P6) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5,
P6  p6 
) [inline]

Definition at line 1918 of file callback.h.

template<class R, class P1, class P2, class P3, class P4, class P5>
_FunctionResultCallback_5_0<false,R,P1,P2,P3,P4,P5>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4, P5)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 1816 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
_MemberResultCallback_5_0<false,R,T1,P1,P2,P3,P4,P5>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 1722 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4, class P5>
_ConstMemberResultCallback_5_0<false,R,T1,P1,P2,P3,P4,P5>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4, P5) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4,
P5  p5 
) [inline]

Definition at line 1621 of file callback.h.

template<class R, class P1, class P2, class P3, class P4>
_FunctionResultCallback_4_0<false,R,P1,P2,P3,P4>::base* NewPermanentCallback ( R(*)(P1, P2, P3, P4)  function,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 1521 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4>
_MemberResultCallback_4_0<false,R,T1,P1,P2,P3,P4>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3, P4)  member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 1429 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3, class P4>
_ConstMemberResultCallback_4_0<false,R,T1,P1,P2,P3,P4>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3, P4) const   member,
P1  p1,
P2  p2,
P3  p3,
P4  p4 
) [inline]

Definition at line 1330 of file callback.h.

template<class R, class P1, class P2, class P3>
_FunctionResultCallback_3_0<false,R,P1,P2,P3>::base* NewPermanentCallback ( R(*)(P1, P2, P3)  function,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 1232 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3>
_MemberResultCallback_3_0<false,R,T1,P1,P2,P3>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2, P3)  member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 1142 of file callback.h.

template<class T1, class T2, class R, class P1, class P2, class P3>
_ConstMemberResultCallback_3_0<false,R,T1,P1,P2,P3>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2, P3) const   member,
P1  p1,
P2  p2,
P3  p3 
) [inline]

Definition at line 1045 of file callback.h.

template<class R, class P1, class P2>
_FunctionResultCallback_2_0<false,R,P1,P2>::base* NewPermanentCallback ( R(*)(P1, P2)  function,
P1  p1,
P2  p2 
) [inline]

Definition at line 949 of file callback.h.

template<class T1, class T2, class R, class P1, class P2>
_MemberResultCallback_2_0<false,R,T1,P1,P2>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1, P2)  member,
P1  p1,
P2  p2 
) [inline]

Definition at line 861 of file callback.h.

template<class T1, class T2, class R, class P1, class P2>
_ConstMemberResultCallback_2_0<false,R,T1,P1,P2>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1, P2) const   member,
P1  p1,
P2  p2 
) [inline]

Definition at line 766 of file callback.h.

template<class R, class P1>
_FunctionResultCallback_1_0<false,R,P1>::base* NewPermanentCallback ( R(*)(P1)  function,
P1  p1 
) [inline]

Definition at line 672 of file callback.h.

template<class T1, class T2, class R, class P1>
_MemberResultCallback_1_0<false,R,T1,P1>::base* NewPermanentCallback ( T1 *  obj,
R(T2::*)(P1)  member,
P1  p1 
) [inline]

Definition at line 586 of file callback.h.

template<class T1, class T2, class R, class P1>
_ConstMemberResultCallback_1_0<false,R,T1,P1>::base* NewPermanentCallback ( const T1 *  obj,
R(T2::*)(P1) const   member,
P1  p1 
) [inline]

Definition at line 492 of file callback.h.

template<class R>
_FunctionResultCallback_0_0<false,R>::base* NewPermanentCallback ( R(*)()  function  )  [inline]

Definition at line 399 of file callback.h.

template<class T1, class T2, class R>
_MemberResultCallback_0_0<false,R,T1>::base* @6::NewPermanentCallback ( T1 *  obj,
R(T2::*)()  member 
) [inline, static]

Definition at line 315 of file callback.h.

template<class T1, class T2, class R>
_ConstMemberResultCallback_0_0<false,R,T1>::base* @6::NewPermanentCallback ( const T1 *  obj,
R(T2::*)() const   member 
) [inline, static]

Definition at line 225 of file callback.h.

Variable Documentation

FunctionSignature function_

Definition at line 327 of file callback.h.

MemberSignature member_

Definition at line 148 of file callback.h.

T* object_

Definition at line 147 of file callback.h.

P1 p1_

Definition at line 413 of file callback.h.

P2 p2_

Definition at line 687 of file callback.h.

P3 p3_

Definition at line 965 of file callback.h.

P4 p4_

Definition at line 1249 of file callback.h.

P5 p5_

Definition at line 1539 of file callback.h.

P6 p6_

Definition at line 1835 of file callback.h.