uobject.hh File Reference

#include <string>
#include <list>
#include <algorithm>
#include "libport/singleton-ptr.hh"
#include "libport/ufloat.h"
#include "libport/hash.hh"
#include "urbi/fwd.hh"
#include "urbi/ubinary.hh"
#include "urbi/utypes-common.hh"
#include "urbi/uvalue.hh"
#include "urbi/uvar.hh"

Go to the source code of this file.

Namespaces

namespace  urbi

Classes

class  urbi::UGenericCallback
 Function and Event storage mechanism. More...
class  urbi::UTimerCallback
 Timer mechanism. More...
class  urbi::UTimerCallbackobj< T >
class  urbi::UObject
 Main UObject class definition Each UObject instance corresponds to an URBI object. More...
class  urbi::UObjectHub
 Main UObjectHub class definition. More...
class  urbi::baseURBIStarter
 URBIStarter base class used to store heterogeneous template class objects in starterlist. More...
class  urbi::URBIStarter< T >
 A starter is a class whose job is to start an instance of a particular UObject subclass, resulting in the initialization of this object (registration to the kernel). More...
class  urbi::baseURBIStarterHub
 URBIStarter base class used to store heterogeneous template class objects in starterlist. More...
class  urbi::URBIStarterHub< T >
 A starter is a class whose job is to start an instance of a particular UObject subclass, resulting in the initialization of this object (registration to the kernel). More...
class  urbi::utrait< T >
class  urbi::utrait< T & >
class  urbi::UCallback0< OBJ, R >
class  urbi::UCallbackvoid0< OBJ >
class  urbi::UCallbacknotifyend0< OBJ >
class  urbi::UFCallbackvoid0< INU >
class  urbi::UFCallback0< R >
class  urbi::UCallback1< OBJ, R, P1 >
class  urbi::UCallbackvoid1< OBJ, P1 >
class  urbi::UCallbacknotifyend1< OBJ, P1 >
class  urbi::UFCallbackvoid1< INU, P1 >
class  urbi::UFCallback1< R, P1 >
class  urbi::UCallback2< OBJ, R, P1, P2 >
class  urbi::UCallbackvoid2< OBJ, P1, P2 >
class  urbi::UCallbacknotifyend2< OBJ, P1, P2 >
class  urbi::UFCallbackvoid2< INU, P1, P2 >
class  urbi::UFCallback2< R, P1, P2 >
class  urbi::UCallback3< OBJ, R, P1, P2, P3 >
class  urbi::UCallbackvoid3< OBJ, P1, P2, P3 >
class  urbi::UCallbacknotifyend3< OBJ, P1, P2, P3 >
class  urbi::UFCallbackvoid3< INU, P1, P2, P3 >
class  urbi::UFCallback3< R, P1, P2, P3 >
class  urbi::UCallback4< OBJ, R, P1, P2, P3, P4 >
class  urbi::UCallbackvoid4< OBJ, P1, P2, P3, P4 >
class  urbi::UCallbacknotifyend4< OBJ, P1, P2, P3, P4 >
class  urbi::UFCallbackvoid4< INU, P1, P2, P3, P4 >
class  urbi::UFCallback4< R, P1, P2, P3, P4 >
class  urbi::UCallback5< OBJ, R, P1, P2, P3, P4, P5 >
class  urbi::UCallbackvoid5< OBJ, P1, P2, P3, P4, P5 >
class  urbi::UCallbacknotifyend5< OBJ, P1, P2, P3, P4, P5 >
class  urbi::UFCallbackvoid5< INU, 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::UCallbackvoid6< OBJ, P1, P2, P3, P4, P5, P6 >
class  urbi::UCallbacknotifyend6< OBJ, P1, P2, P3, P4, P5, P6 >
class  urbi::UFCallbackvoid6< INU, 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::UCallbackvoid7< OBJ, P1, P2, P3, P4, P5, P6, P7 >
class  urbi::UCallbacknotifyend7< OBJ, P1, P2, P3, P4, P5, P6, P7 >
class  urbi::UFCallbackvoid7< INU, 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::UCallbackvoid8< OBJ, P1, P2, P3, P4, P5, P6, P7, P8 >
class  urbi::UCallbacknotifyend8< OBJ, P1, P2, P3, P4, P5, P6, P7, P8 >
class  urbi::UFCallbackvoid8< INU, 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::UCallbackvoid9< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9 >
class  urbi::UCallbacknotifyend9< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9 >
class  urbi::UFCallbackvoid9< INU, 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::UCallbackvoid10< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >
class  urbi::UCallbacknotifyend10< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >
class  urbi::UFCallbackvoid10< INU, 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::UCallbackvoid11< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >
class  urbi::UCallbacknotifyend11< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >
class  urbi::UFCallbackvoid11< INU, 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::UCallbackvoid12< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >
class  urbi::UCallbacknotifyend12< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >
class  urbi::UFCallbackvoid12< INU, 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::UCallbackvoid13< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >
class  urbi::UCallbacknotifyend13< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >
class  urbi::UFCallbackvoid13< INU, 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::UCallbackvoid14< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >
class  urbi::UCallbacknotifyend14< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 >
class  urbi::UFCallbackvoid14< INU, 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::UCallbackvoid15< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >
class  urbi::UCallbacknotifyend15< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 >
class  urbi::UFCallbackvoid15< INU, 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::UCallbackvoid16< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16 >
class  urbi::UCallbacknotifyend16< OBJ, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16 >
class  urbi::UFCallbackvoid16< INU, 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 >

Defines

#define UStart(x)
 This macro must be called once for every UObject class.
#define UStartRename(x, name)
 This macro must be called once for every UObject class.
#define UStartHub(x)
 This macro must be called once for each UObjectHub class.
#define UBindVar(obj, x)   x.init(__name,# x)
 Bind a variable to an object.
#define UOwned(x)   x.setOwned()
 This macro inverts a UVar in/out accesses.
#define USensor(x)   x.setOwned()
#define UBindFunction(obj, x)
 Bind the function x in current URBI object to the C++ member function of same name.
#define UBindEvent(obj, x)
 Registers a function x in current object that will be called each time the event of same name is triggered.
#define UBindEventEnd(obj, x, fun)
 Registers a function x in current object that will be called each time the event of same name is triggered, and a function fun called when the event ends.
#define URegister(hub)
 Register current object to the UObjectHub named 'hub'.
#define URBI(a)   ::urbi::uobject_unarmorAndSend(# a)
 Send unquoted URBI commands to the server.
#define SETCAST(Type)

Typedefs

typedef libport::hash_map_type<
std::string, std::list< UGenericCallback
* > >::type 
urbi::UTable
typedef libport::hash_map_type<
std::string, std::list< UVar
* > >::type 
urbi::UVarTable
typedef std::list< baseURBIStarter * > urbi::UStartlist
typedef std::list< baseURBIStarterHub * > urbi::UStartlistHub
typedef std::list< UTimerCallback * > urbi::UTimerTable
typedef std::list< UObject * > urbi::UObjectList
typedef int urbi::UReturn

Functions

 urbi::EXTERN_STATIC_INSTANCE (UStartlist, objectlist)
 urbi::EXTERN_STATIC_INSTANCE (UStartlistHub, objecthublist)
void urbi::main (int argc, char *argv[])
 Send a binary file to the URBI server, to be saved in a variable.
void urbi::echo (const char *format,...)
 echo method
UObjectHub * urbi::getUObjectHub (const std::string &n)
 retrieve a UObjectHub based on its name
UObject * urbi::getUObject (const std::string &n)
 retrieve a UObject based on its name
void urbi::uobject_unarmorAndSend (const char *str)
 Send URBI code (ghost connection in plugin mode, default connection in remote mode).
void urbi::send (const char *str)
 Send the string to the connection hosting the UObject.
void urbi::send (void *buf, int size)
 Send buf to the connection hosting the UObject.
const UValue & urbi::cast (UValue &val, const UValue *)
UValue urbi::cast (UValue &val, UValue *)
 urbi::SETCAST (int)
 urbi::SETCAST (unsigned int)
 urbi::SETCAST (long)
 urbi::SETCAST (ufloat)
 urbi::SETCAST (std::string)
 urbi::SETCAST (bool)
 urbi::SETCAST (UImage)
 urbi::SETCAST (USound)
UVar & urbi::cast (UValue &val, UVar *var)
UBinary urbi::cast (UValue &v, UBinary *b)
UList urbi::cast (UValue &v, UList *l)
UObjectStruct urbi::cast (UValue &v, UObjectStruct *o)
const char * urbi::cast (UValue &v, const char **b)
template<class I>
std::list< I > urbi::cast (UValue &val, std::list< I > *inu)
template<class R>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, R(*fun)(), const std::string &funname, UTable &t)
template<>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, void(*fun)(), const std::string &funname, UTable &t)
template<class OBJ, class R>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(), const std::string &funname, UTable &t)
template<class OBJ>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(), const std::string &funname, UTable &t)
template<class OBJ>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(), void(OBJ::*end)(), const std::string &funname, UTable &t)
template<class R, class P1>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, R(*fun)(P1), const std::string &funname, UTable &t)
template<class P1>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, void(*fun)(P1), const std::string &funname, UTable &t)
template<class OBJ, class R, class P1>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(P1), const std::string &funname, UTable &t)
template<class OBJ, class P1>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1), const std::string &funname, UTable &t)
template<class OBJ, class P1>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1), void(OBJ::*end)(), const std::string &funname, UTable &t)
template<class R, class P1, class P2>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, R(*fun)(P1, P2), const std::string &funname, UTable &t)
template<class P1, class P2>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, void(*fun)(P1, P2), const std::string &funname, UTable &t)
template<class OBJ, class R, class P1, class P2>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(P1, P2), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2), void(OBJ::*end)(), const std::string &funname, UTable &t)
template<class R, class P1, class P2, class P3>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, R(*fun)(P1, P2, P3), const std::string &funname, UTable &t)
template<class P1, class P2, class P3>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, void(*fun)(P1, P2, P3), const std::string &funname, UTable &t)
template<class OBJ, class R, class P1, class P2, class P3>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(P1, P2, P3), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3), void(OBJ::*end)(), const std::string &funname, UTable &t)
template<class R, class P1, class P2, class P3, class P4>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, R(*fun)(P1, P2, P3, P4), const std::string &funname, UTable &t)
template<class P1, class P2, class P3, class P4>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, void(*fun)(P1, P2, P3, P4), const std::string &funname, UTable &t)
template<class OBJ, class R, class P1, class P2, class P3, class P4>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(P1, P2, P3, P4), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3, class P4>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3, class P4>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4), void(OBJ::*end)(), const std::string &funname, UTable &t)
template<class R, class P1, class P2, class P3, class P4, class P5>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, R(*fun)(P1, P2, P3, P4, P5), const std::string &funname, UTable &t)
template<class P1, class P2, class P3, class P4, class P5>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, void(*fun)(P1, P2, P3, P4, P5), const std::string &funname, UTable &t)
template<class OBJ, class R, class P1, class P2, class P3, class P4, class P5>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(P1, P2, P3, P4, P5), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3, class P4, class P5>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3, class P4, class P5>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5), void(OBJ::*end)(), const std::string &funname, UTable &t)
template<class R, class P1, class P2, class P3, class P4, class P5, class P6>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6), const std::string &funname, UTable &t)
template<class P1, class P2, class P3, class P4, class P5, class P6>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, void(*fun)(P1, P2, P3, P4, P5, P6), const std::string &funname, UTable &t)
template<class OBJ, class R, class P1, class P2, class P3, class P4, class P5, class P6>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(P1, P2, P3, P4, P5, P6), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3, class P4, class P5, class P6>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3, class P4, class P5, class P6>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6), void(OBJ::*end)(), const std::string &funname, UTable &t)
template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7), const std::string &funname, UTable &t)
template<class P1, class P2, class P3, class P4, class P5, class P6, class P7>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, void(*fun)(P1, P2, P3, P4, P5, P6, P7), const std::string &funname, UTable &t)
template<class OBJ, class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7), void(OBJ::*end)(), const std::string &funname, UTable &t)
template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8), const std::string &funname, UTable &t)
template<class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, void(*fun)(P1, P2, P3, P4, P5, P6, P7, P8), const std::string &funname, UTable &t)
template<class OBJ, class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8), void(OBJ::*end)(), const std::string &funname, UTable &t)
template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9), const std::string &funname, UTable &t)
template<class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, void(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9), const std::string &funname, UTable &t)
template<class OBJ, class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9), void(OBJ::*end)(), const std::string &funname, UTable &t)
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 (const std::string &objname, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), const std::string &funname, UTable &t)
template<class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, void(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), const std::string &funname, UTable &t)
template<class OBJ, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10>
UGenericCallback * urbi::createUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), void(OBJ::*end)(), const std::string &funname, UTable &t)
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 (const std::string &objname, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), const std::string &funname, UTable &t)
template<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 (const std::string &objname, const std::string &type, void(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), void(OBJ::*end)(), const std::string &funname, UTable &t)
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 (const std::string &objname, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), const std::string &funname, UTable &t)
template<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 (const std::string &objname, const std::string &type, void(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), void(OBJ::*end)(), const std::string &funname, UTable &t)
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 (const std::string &objname, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13), const std::string &funname, UTable &t)
template<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 (const std::string &objname, const std::string &type, void(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13), void(OBJ::*end)(), const std::string &funname, UTable &t)
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 (const std::string &objname, const std::string &type, R(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14), const std::string &funname, UTable &t)
template<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 (const std::string &objname, const std::string &type, void(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14), void(OBJ::*end)(), const std::string &funname, UTable &t)
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 (const std::string &objname, 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, UTable &t)
template<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 (const std::string &objname, const std::string &type, void(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, 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 std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15), void(OBJ::*end)(), const std::string &funname, UTable &t)
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 (const std::string &objname, 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, UTable &t)
template<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 (const std::string &objname, const std::string &type, void(*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, 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 std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16), const std::string &funname, UTable &t)
template<class OBJ, 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 (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16), void(OBJ::*end)(), const std::string &funname, UTable &t)

Variables

UVarTable urbi::varmap
UTable urbi::functionmap
UTable urbi::eventmap
UTable urbi::eventendmap
UTable urbi::monitormap
UTable urbi::accessmap
UTimerTable urbi::timermap
UTimerTable urbi::updatemap
UObject * urbi::dummyUObject
 an empty dummy UObject used by UVar to set a NotifyChange This avoid coupling a UVar to a particular object


Detailed Description

File: uobject.hh
Definition of the UObject class and necessary related classes.

This file is part of UObject Component Architecture
(c) 2006 Gostai S.A.S.

Permission to use, copy, modify, and redistribute this software for non-commercial use is hereby granted.

This software is provided "as is" without warranty of any kind, either expressed or implied, including but not limited to the implied warranties of fitness for a particular purpose.

For more information, comments, bug reports: http://www.urbiforge.com

Definition in file uobject.hh.


Define Documentation

#define SETCAST ( Type   ) 

Value:

inline Type                                     \
  cast(UValue &val, Type*)                      \
  {                                             \
    return (Type)val;                           \
  }

Definition at line 412 of file uobject.hh.

#define UBindEvent ( obj,
 ) 

Value:

::urbi::createUCallback(__name, "event", this,                  \
                          (&obj::x),__name+"."+std::string(# x),        \
			  ::urbi::eventmap)
Registers a function x in current object that will be called each time the event of same name is triggered.

The function will be called only if the number of arguments match between the function prototype and the URBI event.

Definition at line 87 of file uobject.hh.

#define UBindEventEnd ( obj,
x,
fun   ) 

Value:

::urbi::createUCallback(__name, "eventend", this,                       \
                          (&obj::x),(&obj::fun),__name+"."+std::string(# x), \
			  ::urbi::eventendmap)
Registers a function x in current object that will be called each time the event of same name is triggered, and a function fun called when the event ends.

The function will be called only if the number of arguments match between the function prototype and the URBI event.

Definition at line 98 of file uobject.hh.

#define UBindFunction ( obj,
 ) 

Value:

::urbi::createUCallback(__name, "function", this,                       \
                          (&obj::x),__name+"."+std::string(# x),        \
			  ::urbi::functionmap)
Bind the function x in current URBI object to the C++ member function of same name.

The return value and parameters must be of a basic integral or floating types, char *, std::string, UValue, UBinary, USound or UImage, or any type that can cast to/from UValue.

Definition at line 77 of file uobject.hh.

#define UBindVar ( obj,
 )     x.init(__name,# x)

Bind a variable to an object.

This macro can only be called from within a class inheriting from UObject. It binds the UVar x within the object to a variable with the same name in the corresponding URBI object.

Definition at line 59 of file uobject.hh.

#define UOwned (  )     x.setOwned()

This macro inverts a UVar in/out accesses.

After this call is made, writes by this module affect the sensed value, and reads read the target value. Writes by other modules and URBI code affect the target value, and reads get the sensed value. Without this call, all operations affect the same underlying variable.

Definition at line 68 of file uobject.hh.

#define URBI (  )     ::urbi::uobject_unarmorAndSend(# a)

Send unquoted URBI commands to the server.

Add an extra layer of parenthesis for safety.

Definition at line 119 of file uobject.hh.

Referenced by urbi::dispatcher(), urbi::UVar::getProp(), urbi::UVar::operator=(), urbi::UVar::requestValue(), urbi::UVar::setProp(), urbi::UVar::syncValue(), urbi::UGenericCallback::UGenericCallback(), urbi::UObject::UObject(), urbi::UObject::USetUpdate(), and urbi::UTimerCallback::UTimerCallback().

#define URegister ( hub   ) 

Value:

do {                                                            \
    objecthub = ::urbi::getUObjectHub((std::string) #hub);      \
    if (objecthub)                                              \
      objecthub->addMember(dynamic_cast<UObject*>(this));       \
    else                                                        \
      ::urbi::echo("Error: hub name '%s' is unknown\n", #hub);  \
  } while (0)
Register current object to the UObjectHub named 'hub'.

Definition at line 104 of file uobject.hh.

#define UStart (  ) 

Value:

::urbi::URBIStarter<x> x ##  ____URBI_object(std::string(# x),  \
                                               ::urbi::objectlist)
This macro must be called once for every UObject class.

Definition at line 39 of file uobject.hh.

#define UStartHub (  ) 

Value:

::urbi::URBIStarterHub<x> x ##  ____URBI_object(std::string(# x),       \
                                                  ::urbi::objecthublist)
This macro must be called once for each UObjectHub class.

Definition at line 49 of file uobject.hh.

#define UStartRename ( x,
name   ) 

Value:

::urbi::URBIStarter<x> x ##  ____URBI_object(std::string(# name),       \
                                               ::urbi::objectlist)
This macro must be called once for every UObject class.

Definition at line 44 of file uobject.hh.


Generated on Tue Apr 10 17:45:45 2007 for URBISDK by  doxygen 1.5.1