|
| ||||||||||||||||
| template <class R>
typename XorpCallback0<R>::RefPtr
callback (R (*f)())
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 0 dispatch time arguments and 0 bound arguments.
| template <class R, class O> typename XorpCallback0<R>::RefPtr
callback ( O* o, R (O::*p)())
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 0 dispatch time arguments and 0 bound arguments.
| template <class R, class O> typename XorpCallback0<R>::RefPtr
callback ( O& o, R (O::*p)())
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 0 dispatch time arguments and 0 bound arguments.
| template <class R, class O> typename XorpCallback0<R>::RefPtr
callback ( const O* o, R (O::*p)() const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 0 dispatch time arguments and 0 bound arguments.
| template <class R, class O> typename XorpCallback0<R>::RefPtr
callback ( const O& o, R (O::*p)() const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 0 dispatch time arguments and 0 bound arguments.
| template <class R, class BA1>
typename XorpCallback0<R>::RefPtr
callback (R (*f)(BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 0 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class BA1> typename XorpCallback0<R>::RefPtr
callback ( O* o, R (O::*p)(BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 0 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class BA1> typename XorpCallback0<R>::RefPtr
callback ( O& o, R (O::*p)(BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 0 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class BA1> typename XorpCallback0<R>::RefPtr
callback ( const O* o, R (O::*p)(BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 0 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class BA1> typename XorpCallback0<R>::RefPtr
callback ( const O& o, R (O::*p)(BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 0 dispatch time arguments and 1 bound arguments.
| template <class R, class BA1, class BA2>
typename XorpCallback0<R>::RefPtr
callback (R (*f)(BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 0 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class BA1, class BA2> typename XorpCallback0<R>::RefPtr
callback ( O* o, R (O::*p)(BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 0 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class BA1, class BA2> typename XorpCallback0<R>::RefPtr
callback ( O& o, R (O::*p)(BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 0 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class BA1, class BA2> typename XorpCallback0<R>::RefPtr
callback ( const O* o, R (O::*p)(BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 0 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class BA1, class BA2> typename XorpCallback0<R>::RefPtr
callback ( const O& o, R (O::*p)(BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 0 dispatch time arguments and 2 bound arguments.
| template <class R, class BA1, class BA2, class BA3>
typename XorpCallback0<R>::RefPtr
callback (R (*f)(BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 0 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3> typename XorpCallback0<R>::RefPtr
callback ( O* o, R (O::*p)(BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 0 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3> typename XorpCallback0<R>::RefPtr
callback ( O& o, R (O::*p)(BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 0 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3> typename XorpCallback0<R>::RefPtr
callback ( const O* o, R (O::*p)(BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 0 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3> typename XorpCallback0<R>::RefPtr
callback ( const O& o, R (O::*p)(BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 0 dispatch time arguments and 3 bound arguments.
| template <class R, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback0<R>::RefPtr
callback (R (*f)(BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 0 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3, class BA4> typename XorpCallback0<R>::RefPtr
callback ( O* o, R (O::*p)(BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 0 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3, class BA4> typename XorpCallback0<R>::RefPtr
callback ( O& o, R (O::*p)(BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 0 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3, class BA4> typename XorpCallback0<R>::RefPtr
callback ( const O* o, R (O::*p)(BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 0 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3, class BA4> typename XorpCallback0<R>::RefPtr
callback ( const O& o, R (O::*p)(BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 0 dispatch time arguments and 4 bound arguments.
| template <class R, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback0<R>::RefPtr
callback (R (*f)(BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 0 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback0<R>::RefPtr
callback ( O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 0 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback0<R>::RefPtr
callback ( O& o, R (O::*p)(BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 0 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback0<R>::RefPtr
callback ( const O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 0 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback0<R>::RefPtr
callback ( const O& o, R (O::*p)(BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 0 dispatch time arguments and 5 bound arguments.
| template <class R, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback0<R>::RefPtr
callback (R (*f)(BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 0 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback0<R>::RefPtr
callback ( O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 0 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback0<R>::RefPtr
callback ( O& o, R (O::*p)(BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 0 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback0<R>::RefPtr
callback ( const O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 0 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback0<R>::RefPtr
callback ( const O& o, R (O::*p)(BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 0 dispatch time arguments and 6 bound arguments.
| template <class R, class A1>
typename XorpCallback1<R, A1>::RefPtr
callback (R (*f)(A1))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 1 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1> typename XorpCallback1<R, A1>::RefPtr
callback ( O* o, R (O::*p)(A1))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 1 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1> typename XorpCallback1<R, A1>::RefPtr
callback ( O& o, R (O::*p)(A1))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 1 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1> typename XorpCallback1<R, A1>::RefPtr
callback ( const O* o, R (O::*p)(A1) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 1 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1> typename XorpCallback1<R, A1>::RefPtr
callback ( const O& o, R (O::*p)(A1) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 1 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class BA1>
typename XorpCallback1<R, A1>::RefPtr
callback (R (*f)(A1, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 1 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class BA1> typename XorpCallback1<R, A1>::RefPtr
callback ( O* o, R (O::*p)(A1, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 1 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class BA1> typename XorpCallback1<R, A1>::RefPtr
callback ( O& o, R (O::*p)(A1, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 1 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class BA1> typename XorpCallback1<R, A1>::RefPtr
callback ( const O* o, R (O::*p)(A1, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 1 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class BA1> typename XorpCallback1<R, A1>::RefPtr
callback ( const O& o, R (O::*p)(A1, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 1 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class BA1, class BA2>
typename XorpCallback1<R, A1>::RefPtr
callback (R (*f)(A1, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 1 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2> typename XorpCallback1<R, A1>::RefPtr
callback ( O* o, R (O::*p)(A1, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 1 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2> typename XorpCallback1<R, A1>::RefPtr
callback ( O& o, R (O::*p)(A1, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 1 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2> typename XorpCallback1<R, A1>::RefPtr
callback ( const O* o, R (O::*p)(A1, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 1 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2> typename XorpCallback1<R, A1>::RefPtr
callback ( const O& o, R (O::*p)(A1, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 1 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class BA1, class BA2, class BA3>
typename XorpCallback1<R, A1>::RefPtr
callback (R (*f)(A1, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 1 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3> typename XorpCallback1<R, A1>::RefPtr
callback ( O* o, R (O::*p)(A1, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 1 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3> typename XorpCallback1<R, A1>::RefPtr
callback ( O& o, R (O::*p)(A1, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 1 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3> typename XorpCallback1<R, A1>::RefPtr
callback ( const O* o, R (O::*p)(A1, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 1 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3> typename XorpCallback1<R, A1>::RefPtr
callback ( const O& o, R (O::*p)(A1, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 1 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback1<R, A1>::RefPtr
callback (R (*f)(A1, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 1 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4> typename XorpCallback1<R, A1>::RefPtr
callback ( O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 1 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4> typename XorpCallback1<R, A1>::RefPtr
callback ( O& o, R (O::*p)(A1, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 1 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4> typename XorpCallback1<R, A1>::RefPtr
callback ( const O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 1 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4> typename XorpCallback1<R, A1>::RefPtr
callback ( const O& o, R (O::*p)(A1, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 1 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback1<R, A1>::RefPtr
callback (R (*f)(A1, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 1 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback1<R, A1>::RefPtr
callback ( O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 1 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback1<R, A1>::RefPtr
callback ( O& o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 1 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback1<R, A1>::RefPtr
callback ( const O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 1 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback1<R, A1>::RefPtr
callback ( const O& o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 1 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback1<R, A1>::RefPtr
callback (R (*f)(A1, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 1 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback1<R, A1>::RefPtr
callback ( O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 1 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback1<R, A1>::RefPtr
callback ( O& o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 1 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback1<R, A1>::RefPtr
callback ( const O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 1 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback1<R, A1>::RefPtr
callback ( const O& o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 1 dispatch time arguments and 6 bound arguments.
| template <class R, class A1, class A2>
typename XorpCallback2<R, A1, A2>::RefPtr
callback (R (*f)(A1, A2))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 2 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( O* o, R (O::*p)(A1, A2))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 2 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( O& o, R (O::*p)(A1, A2))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 2 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 2 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 2 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class A2, class BA1>
typename XorpCallback2<R, A1, A2>::RefPtr
callback (R (*f)(A1, A2, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 2 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class BA1> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 2 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class BA1> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 2 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class BA1> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 2 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class BA1> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 2 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class A2, class BA1, class BA2>
typename XorpCallback2<R, A1, A2>::RefPtr
callback (R (*f)(A1, A2, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 2 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 2 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 2 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 2 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 2 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class A2, class BA1, class BA2, class BA3>
typename XorpCallback2<R, A1, A2>::RefPtr
callback (R (*f)(A1, A2, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 2 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 2 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 2 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 2 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 2 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class A2, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback2<R, A1, A2>::RefPtr
callback (R (*f)(A1, A2, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 2 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 2 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 2 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 2 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 2 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback2<R, A1, A2>::RefPtr
callback (R (*f)(A1, A2, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 2 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 2 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 2 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 2 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 2 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback2<R, A1, A2>::RefPtr
callback (R (*f)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 2 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 2 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 2 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 2 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback2<R, A1, A2>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 2 dispatch time arguments and 6 bound arguments.
| template <class R, class A1, class A2, class A3>
typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback (R (*f)(A1, A2, A3))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 3 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 3 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 3 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 3 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 3 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class A2, class A3, class BA1>
typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback (R (*f)(A1, A2, A3, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 3 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 3 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 3 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 3 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 3 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class A2, class A3, class BA1, class BA2>
typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback (R (*f)(A1, A2, A3, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 3 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 3 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 3 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 3 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 3 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class A2, class A3, class BA1, class BA2, class BA3>
typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback (R (*f)(A1, A2, A3, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 3 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 3 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 3 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 3 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 3 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback (R (*f)(A1, A2, A3, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 3 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 3 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 3 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 3 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 3 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback (R (*f)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 3 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 3 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 3 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 3 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 3 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback (R (*f)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 3 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 3 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 3 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 3 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback3<R, A1, A2, A3>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 3 dispatch time arguments and 6 bound arguments.
| template <class R, class A1, class A2, class A3, class A4>
typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback (R (*f)(A1, A2, A3, A4))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 4 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 4 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 4 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 4 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 4 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class BA1>
typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback (R (*f)(A1, A2, A3, A4, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 4 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 4 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 4 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 4 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 4 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2>
typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback (R (*f)(A1, A2, A3, A4, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 4 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 4 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 4 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 4 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 4 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3>
typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback (R (*f)(A1, A2, A3, A4, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 4 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 4 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 4 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 4 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 4 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback (R (*f)(A1, A2, A3, A4, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 4 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 4 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 4 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 4 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 4 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback (R (*f)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 4 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 4 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 4 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 4 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 4 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback (R (*f)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 4 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 4 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 4 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 4 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 4 dispatch time arguments and 6 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5>
typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 5 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 5 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 5 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 5 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 5 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class BA1>
typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 5 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 5 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 5 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 5 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 5 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2>
typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 5 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 5 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 5 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 5 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 5 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3>
typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 5 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 5 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 5 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 5 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 5 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 5 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 5 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 5 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 5 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 5 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 5 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 5 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 5 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 5 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 5 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 5 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 5 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 5 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 5 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 5 dispatch time arguments and 6 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 6 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 6 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 6 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 6 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 6 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1>
typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 6 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 6 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 6 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 6 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 6 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2>
typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 6 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 6 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 6 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 6 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 6 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3>
typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 6 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 6 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 6 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 6 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 6 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 6 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 6 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 6 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 6 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 6 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 6 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 6 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 6 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 6 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 6 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 6 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 6 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 6 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 6 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 6 dispatch time arguments and 6 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 7 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 7 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 7 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 7 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 7 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1>
typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 7 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 7 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 7 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 7 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 7 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2>
typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 7 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 7 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 7 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 7 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 7 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3>
typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 7 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 7 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 7 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 7 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 7 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 7 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 7 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 7 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 7 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 7 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 7 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 7 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 7 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 7 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 7 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 7 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 7 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 7 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 7 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 7 dispatch time arguments and 6 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 8 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 8 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 8 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 8 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 8 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1>
typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 8 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 8 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 8 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 8 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 8 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2>
typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 8 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 8 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 8 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 8 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 8 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3>
typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 8 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 8 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 8 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 8 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 8 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 8 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 8 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 8 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 8 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 8 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 8 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 8 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 8 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 8 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 8 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 8 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 8 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 8 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 8 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 8 dispatch time arguments and 6 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 9 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 9 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 9 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 9 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 9 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1>
typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 9 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 9 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 9 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 9 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 9 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2>
typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 9 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 9 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 9 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 9 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 9 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3>
typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 9 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 9 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 9 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 9 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 9 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 9 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 9 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 9 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 9 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 9 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 9 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 9 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 9 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 9 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 9 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 9 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 9 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 9 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 9 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 9 dispatch time arguments and 6 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 10 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 10 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 10 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 10 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 10 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1>
typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 10 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 10 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 10 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 10 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 10 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2>
typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 10 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 10 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 10 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 10 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 10 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3>
typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 10 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 10 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 10 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 10 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 10 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 10 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 10 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 10 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 10 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 10 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 10 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 10 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 10 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 10 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 10 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 10 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 10 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 10 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 10 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 10 dispatch time arguments and 6 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 11 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 11 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 11 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 11 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 11 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1>
typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 11 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 11 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 11 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 11 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 11 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2>
typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 11 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 11 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 11 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 11 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 11 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3>
typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 11 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 11 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 11 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 11 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 11 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 11 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 11 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 11 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 11 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 11 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 11 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 11 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 11 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 11 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 11 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 11 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 11 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 11 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 11 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 11 dispatch time arguments and 6 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 12 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 12 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 12 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 12 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 12 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1>
typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 12 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 12 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 12 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 12 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 12 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2>
typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 12 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 12 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 12 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 12 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 12 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3>
typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 12 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 12 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 12 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 12 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 12 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 12 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 12 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 12 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 12 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 12 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 12 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 12 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 12 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 12 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 12 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 12 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 12 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 12 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 12 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 12 dispatch time arguments and 6 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 13 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 13 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 13 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 13 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 13 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1>
typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 13 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 13 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 13 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 13 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 13 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2>
typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 13 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 13 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 13 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 13 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 13 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3>
typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 13 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 13 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 13 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 13 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 13 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 13 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 13 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 13 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 13 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 13 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 13 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 13 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 13 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 13 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 13 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 13 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 13 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 13 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 13 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 13 dispatch time arguments and 6 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 14 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 14 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 14 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 14 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 14 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1>
typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 14 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 14 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 14 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 14 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 14 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2>
typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 14 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 14 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 14 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 14 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 14 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3>
typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 14 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 14 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 14 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 14 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 14 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 14 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 14 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 14 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 14 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 14 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 14 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 14 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 14 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 14 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 14 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 14 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 14 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 14 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 14 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 14 dispatch time arguments and 6 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 15 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 15 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 15 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 15 dispatch time arguments and 0 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) const)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 15 dispatch time arguments and 0 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1>
typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 15 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 15 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1), BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 15 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 15 dispatch time arguments and 1 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1) const, BA1 ba1)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 15 dispatch time arguments and 1 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2>
typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 15 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 15 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2), BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 15 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 15 dispatch time arguments and 2 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2) const, BA1 ba1, BA2 ba2)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 15 dispatch time arguments and 2 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3>
typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 15 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 15 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 15 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 15 dispatch time arguments and 3 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 15 dispatch time arguments and 3 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 15 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 15 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 15 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 15 dispatch time arguments and 4 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 15 dispatch time arguments and 4 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 15 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 15 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 15 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 15 dispatch time arguments and 5 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 15 dispatch time arguments and 5 bound arguments.
| template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback (R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a function with 15 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 15 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a member function with 15 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 15 dispatch time arguments and 6 bound arguments.
| template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
callback ( const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
| callback |
#include <callback_nodebug.hh>
Factory function that creates a callback object targetted at a const member function with 15 dispatch time arguments and 6 bound arguments.
