Urbi SDK Remote for C++  2.7.5
ucallbacks.hh File Reference
#include <string>
#include <libport/compiler.hh>
#include <libport/meta.hh>
#include <libport/preproc.hh>
#include <libport/thread-pool.hh>
#include <urbi/export.hh>
#include <urbi/fwd.hh>
#include <urbi/utable.hh>
#include <urbi/uvalue.hh>
#include <urbi/ucontext.hh>
#include <urbi/uvar.hh>
#include <boost/function.hpp>
Include dependency graph for ucallbacks.hh:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  urbi::impl::UGenericCallbackImpl
class  urbi::UGenericCallback
 Function and Event storage mechanism This heavily overloaded class is the only way in C++ to make life easy from the the interface user point's of view. More...
class  urbi::UCallback0< OBJ, R >
class  urbi::UFCallback0< R >
class  urbi::UCallback1< OBJ, R, P1 >
class  urbi::UFCallback1< R, P1 >
class  urbi::UCallback2< OBJ, R, P1, P2 >
class  urbi::UFCallback2< R, P1, P2 >
class  urbi::UCallback3< OBJ, R, P1, P2, P3 >
class  urbi::UFCallback3< R, P1, P2, P3 >
class  urbi::UCallback4< OBJ, R, P1, P2, P3, P4 >
class  urbi::UFCallback4< R, P1, P2, P3, P4 >
class  urbi::UCallback5< OBJ, R, P1, P2, P3, P4, P5 >
class  urbi::UFCallback5< R, P1, P2, P3, P4, P5 >
class  urbi::UCallback6< OBJ, R, P1, P2, P3, P4, P5, P6 >
class  urbi::UFCallback6< R, P1, P2, P3, P4, P5, P6 >
class  urbi::UCallback7< OBJ, R, P1, P2, P3, P4, P5, P6, P7 >
class  urbi::UFCallback7< R, P1, P2, P3, P4, P5, P6, P7 >
class  urbi::UCallback8< OBJ, R, P1, P2, P3, P4, P5, P6, P7, P8 >
class  urbi::UFCallback8< R, P1, P2, P3, P4, P5, P6, P7, P8 >
class  urbi::UCallback9< OBJ, R, P1, P2, P3, P4, P5, P6, P7, P8, P9 >
class  urbi::UFCallback9< R, P1, P2, P3, P4, P5, P6, P7, P8, P9 >
class  urbi::UCallback10< OBJ, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >
class  urbi::UFCallback10< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >
class  urbi::UCallback11< OBJ, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >
class  urbi::UFCallback11< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >
class  urbi::UCallback12< OBJ, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >
class  urbi::UFCallback12< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >
class  urbi::UCallback13< OBJ, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >
class  urbi::UFCallback13< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >
class  urbi::UCallback14< OBJ, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >
class  urbi::UFCallback14< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >
class  urbi::UCallback15< OBJ, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >
class  urbi::UFCallback15< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >
class  urbi::UCallback16< OBJ, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16 >
class  urbi::UFCallback16< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16 >
class  urbi::UBoostFunctionCallback0< R >
class  urbi::UBoostFunctionCallback1< R, P1 >
class  urbi::UBoostFunctionCallback2< R, P1, P2 >
class  urbi::UBoostFunctionCallback3< R, P1, P2, P3 >
class  urbi::UBoostFunctionCallback4< R, P1, P2, P3, P4 >
class  urbi::UBoostFunctionCallback5< R, P1, P2, P3, P4, P5 >
class  urbi::UBoostFunctionCallback6< R, P1, P2, P3, P4, P5, P6 >
class  urbi::UBoostFunctionCallback7< R, P1, P2, P3, P4, P5, P6, P7 >
class  urbi::UBoostFunctionCallback8< R, P1, P2, P3, P4, P5, P6, P7, P8 >
class  urbi::UBoostFunctionCallback9< R, P1, P2, P3, P4, P5, P6, P7, P8, P9 >
class  urbi::UBoostFunctionCallback10< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >

Namespaces

namespace  urbi
 

Global definition of the starterlist.


namespace  urbi::impl
 

The interfaces UContextImpl, UVarImpl, UObjectImpl and UGenericCallbackImpl are what must be implemented to make an UObject backend.


Defines

#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)
#define INSTANTIATE(Const, IsConst)
#define INSTANTIATE(Const)

Functions

template<typename T >
uvar_ref_traits< typename
uvalue_cast_return_type< T >
::type >::type 
urbi::uvar_uvalue_cast (UValue &v)
template<>
UVar & urbi::uvar_uvalue_cast< UVar & > (UValue &v)
template<class R >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(), const std::string &funname, impl::UContextImpl *ctx)
 urbi::INSTANTIATE (__)
 urbi::INSTANTIATE (const)
template<class R , class P1 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2, P3), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2, P3, P4), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2, P3, P4, P5), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 , class P11 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 , class P11 , class P12 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 , class P11 , class P12 , class P13 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 , class P11 , class P12 , class P13 , class P14 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 , class P11 , class P12 , class P13 , class P14 , class P15 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15), const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 , class P11 , class P12 , class P13 , class P14 , class P15 , class P16 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16), const std::string &funname, impl::UContextImpl *ctx)
template<class R >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, boost::function0< R > fun, const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, boost::function1< R, P1 > fun, const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, boost::function2< R, P1, P2 > fun, const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, boost::function3< R, P1, P2, P3 > fun, const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, boost::function4< R, P1, P2, P3, P4 > fun, const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, boost::function5< R, P1, P2, P3, P4, P5 > fun, const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, boost::function6< R, P1, P2, P3, P4, P5, P6 > fun, const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, boost::function7< R, P1, P2, P3, P4, P5, P6, P7 > fun, const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, boost::function8< R, P1, P2, P3, P4, P5, P6, P7, P8 > fun, const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, boost::function9< R, P1, P2, P3, P4, P5, P6, P7, P8, P9 > fun, const std::string &funname, impl::UContextImpl *ctx)
template<class R , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 >
UGenericCallback * urbi::createUCallback (UObject &owner, UVar *target, const std::string &type, boost::function10< R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > fun, const std::string &funname, impl::UContextImpl *ctx)

Detailed Description

Definition in file ucallbacks.hh.


Define Documentation

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback0(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) () Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 0,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 0;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R>               \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) () Const,                       \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback0<OBJ,R> (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback1(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 1,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 1;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 >            \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 ) Const,                   \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback1<OBJ,R, P1 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback2(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 2,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 2;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 >         \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 ) Const,                      \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback2<OBJ,R, P1 , P2 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback3(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 , P3 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 3,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 3;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 , class P3 >              \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 , P3 ) Const,                 \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback3<OBJ,R, P1 , P2 , P3 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback4(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 , P3 , P4 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 4,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 4;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 , class P3 , class P4 >           \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 , P3 , P4 ) Const,                    \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback4<OBJ,R, P1 , P2 , P3 , P4 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback5(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 5,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 5;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 , class P3 , class P4 , class P5 >                \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 ) Const,                       \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback5<OBJ,R, P1 , P2 , P3 , P4 , P5 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback6(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 6,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 6;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 , class P3 , class P4 , class P5 , class P6 >             \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 ) Const,                  \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback6<OBJ,R, P1 , P2 , P3 , P4 , P5 , P6 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback7(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 7,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 7;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 >          \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 ) Const,                     \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback7<OBJ,R, P1 , P2 , P3 , P4 , P5 , P6 , P7 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback8(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 8,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 8;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 >               \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 ) Const,                        \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback8<OBJ,R, P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback9(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 9,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 9;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 >            \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 ) Const,                   \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback9<OBJ,R, P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback10(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 10,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 10;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 >                \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 ) Const,                     \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback10<OBJ,R, P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback11(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 11,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 11;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 , class P11 >            \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 ) Const,                       \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback11<OBJ,R, P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback12(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 12,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 12;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 , class P11 , class P12 >                \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 ) Const,                 \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback12<OBJ,R, P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback13(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 , P13 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 13,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 13;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 , class P11 , class P12 , class P13 >            \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 , P13 ) Const,                   \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback13<OBJ,R, P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 , P13 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback14(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 , P13 , P14 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 14,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 14;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 , class P11 , class P12 , class P13 , class P14 >                \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 , P13 , P14 ) Const,                     \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback14<OBJ,R, P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 , P13 , P14 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback15(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 , P13 , P14 , P15 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 15,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 15;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 , class P11 , class P12 , class P13 , class P14 , class P15 >            \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 , P13 , P14 , P15 ) Const,                       \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback15<OBJ,R, P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 , P13 , P14 , P15 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const,
  IsConst 
)
Value:
UCallback16(UObject& owner,                                      \
                   UVar* target,                                        \
                   const std::string& type,                             \
                   OBJ* obj,                                            \
                   R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 , P13 , P14 , P15 , P16 ) Const,                   \
                   const std::string& funname)                          \
      : UGenericCallback                                                \
      (owner, target, type, funname, 16,                               \
       fetchContext(obj,                                                \
                    typename libport::meta::If<libport::meta::Inherits<OBJ, \
                    UContext>::res>::res()))                            \
      , obj(obj)                                                        \
      , fun##Const(fun)                                                 \
      , is_const_(IsConst)                                              \
    {                                                                   \
      nbparam = 16;                                                    \
      registerCallback();                                               \
    }

Definition at line 2147 of file ucallbacks.hh.

#define INSTANTIATE (   Const)
Value:
template <class OBJ, class EOBJ, class R, class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10 , class P11 , class P12 , class P13 , class P14 , class P15 , class P16 >                \
  UGenericCallback*                                                     \
  createUCallback(UObject& owner, UVar* target,                         \
                  const std::string& type,                              \
                  EOBJ* obj,                                            \
                  R (OBJ::*fun) ( P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 , P13 , P14 , P15 , P16 ) Const,                 \
                  const std::string& funname)                           \
  {                                                                     \
    return new UCallback16<OBJ,R, P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 , P11 , P12 , P13 , P14 , P15 , P16 > (owner, target, type,       \
       &dynamic_cast<OBJ&>(*obj), fun, funname);                        \
  }

Definition at line 2147 of file ucallbacks.hh.