urbi Namespace Reference

Global definition of the starterlist. More...


Classes

class  Callback
class  USound
 Class encapsulating sound information. More...
class  UImage
 Class encapsulating an image. More...
class  BinaryData
class  UBinary
 Class containing binary data of known or unknown type. More...
class  UGenericCallback
 Function and Event storage mechanism. More...
class  UTimerCallback
 Timer mechanism. More...
class  UTimerCallbackobj
class  UObject
 Main UObject class definition Each UObject instance corresponds to an URBI object. More...
class  UObjectHub
 Main UObjectHub class definition. More...
class  baseURBIStarter
 URBIStarter base class used to store heterogeneous template class objects in starterlist. More...
class  URBIStarter
 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  baseURBIStarterHub
 URBIStarter base class used to store heterogeneous template class objects in starterlist. More...
class  URBIStarterHub
 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  utrait
class  utrait< T & >
class  UCallback0
class  UCallbackvoid0
class  UCallbacknotifyend0
class  UFCallbackvoid0
class  UFCallback0
class  UCallback1
class  UCallbackvoid1
class  UCallbacknotifyend1
class  UFCallbackvoid1
class  UFCallback1
class  UCallback2
class  UCallbackvoid2
class  UCallbacknotifyend2
class  UFCallbackvoid2
class  UFCallback2
class  UCallback3
class  UCallbackvoid3
class  UCallbacknotifyend3
class  UFCallbackvoid3
class  UFCallback3
class  UCallback4
class  UCallbackvoid4
class  UCallbacknotifyend4
class  UFCallbackvoid4
class  UFCallback4
class  UCallback5
class  UCallbackvoid5
class  UCallbacknotifyend5
class  UFCallbackvoid5
class  UFCallback5
class  UCallback6
class  UCallbackvoid6
class  UCallbacknotifyend6
class  UFCallbackvoid6
class  UFCallback6
class  UCallback7
class  UCallbackvoid7
class  UCallbacknotifyend7
class  UFCallbackvoid7
class  UFCallback7
class  UCallback8
class  UCallbackvoid8
class  UCallbacknotifyend8
class  UFCallbackvoid8
class  UFCallback8
class  UCallback9
class  UCallbackvoid9
class  UCallbacknotifyend9
class  UFCallbackvoid9
class  UFCallback9
class  UCallback10
class  UCallbackvoid10
class  UCallbacknotifyend10
class  UFCallbackvoid10
class  UFCallback10
class  UCallback11
class  UCallbackvoid11
class  UCallbacknotifyend11
class  UFCallbackvoid11
class  UFCallback11
class  UCallback12
class  UCallbackvoid12
class  UCallbacknotifyend12
class  UFCallbackvoid12
class  UFCallback12
class  UCallback13
class  UCallbackvoid13
class  UCallbacknotifyend13
class  UFCallbackvoid13
class  UFCallback13
class  UCallback14
class  UCallbackvoid14
class  UCallbacknotifyend14
class  UFCallbackvoid14
class  UFCallback14
class  UCallback15
class  UCallbackvoid15
class  UCallbacknotifyend15
class  UFCallbackvoid15
class  UFCallback15
class  UCallback16
class  UCallbackvoid16
class  UCallbacknotifyend16
class  UFCallbackvoid16
class  UFCallback16
class  USystemMessage
 USystemMessage class definition. More...
class  UStringSystemMessage
 UStringSystemMessage class definition. More...
class  USystem
 Main USystem class definition. More...
class  UList
 Class storing URBI List type. More...
class  UNamedValue
class  UObjectStruct
class  UValue
 Container for a value that handles all types known to URBI. More...
class  UProp
 Provides easy access to variable properties. More...
class  UVar
 UVar class definition Each UVar instance corresponds to one URBI variable. More...
struct  MovementProperties
 Class Move, first rather trivial implementation. More...
struct  LoadedFile
class  Move

Typedefs

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

Enumerations

enum  UCallbackType { UCB_, UCB_C }
enum  USoundFormat {
  SOUND_RAW, SOUND_WAV, SOUND_MP3, SOUND_OGG,
  SOUND_UNKNOWN
}
 Backward compatibility.
enum  USoundSampleFormat { SAMPLE_SIGNED = 1, SAMPLE_UNSIGNED = 2 }
enum  UImageFormat {
  IMAGE_RGB = 1, IMAGE_YCbCr = 2, IMAGE_JPEG = 3, IMAGE_PPM = 4,
  IMAGE_UNKNOWN
}
enum  UBinaryType { BINARY_NONE, BINARY_UNKNOWN, BINARY_IMAGE, BINARY_SOUND }
enum  USystemChannel { NEW_CHANNEL }
 Possible value types a UValue can contain.
enum  UBlendType {
  UMIX, UADD, UDISCARD, UQUEUE,
  UCANCEL, UNORMAL
}
 Possible blending mode for an UVar.
enum  UProperty {
  PROP_RANGEMIN, PROP_RANGEMAX, PROP_SPEEDMIN, PROP_SPEEDMAX,
  PROP_BLEND, PROP_DELTA
}
 URBI properties associated to a variable.
enum  UDataType {
  DATA_DOUBLE, DATA_STRING, DATA_BINARY, DATA_LIST,
  DATA_OBJECT, DATA_VOID
}
 Possible value types a UValue can contain.
enum  UType { TYPE_BOOL, TYPE_ANGLE, TYPE_NORM }

Functions

static UCallbackAction sendSound_ (void *cb, const UMessage &msg)
std::ostream & operator<< (std::ostream &s, const UMessage &m)
UClient * getDefaultClient ()
void setDefaultClient (UClient *cl)
std::ostream & unarmorAndSend (const char *a)
void execute (void)
void exit (int code)
UClient & connect (const char *host)
void * read_jpeg (const char *jpgbuffer, int jpgbuffer_size, bool RGB, int &output_size)
int write_jpeg (const unsigned char *src, int w, int h, bool ycrcb, unsigned char *dst, int &sz, int quality)
unsigned char clamp (float v)
int convertRGBtoYCrCb (const byte *sourceImage, int bufferSize, byte *destinationImage)
int convertYCrCbtoYCbCr (const byte *sourceImage, int bufferSize, byte *destinationImage)
int convertYCrCbtoRGB (const byte *sourceImage, int bufferSize, byte *destinationImage)
int convertJPEGtoYCrCb (const byte *source, int sourcelen, byte *dest, int &size)
int convertJPEGtoRGB (const byte *source, int sourcelen, byte *dest, int &size)
int convertRGBtoJPEG (const byte *source, int w, int h, byte *dest, int &size, int quality)
int convertYCrCbtoJPEG (const byte *source, int w, int h, byte *dest, int &size, int quality)
void init_source (j_decompress_ptr)
boolean fill_input_buffer (j_decompress_ptr cinfo)
void term_source (j_decompress_ptr)
void skip_input_data (j_decompress_ptr cinfo, long num_bytes)
 urbi_jpeg_error_exit (j_common_ptr cinfo)
void init_destination (j_compress_ptr)
boolean empty_output_buffer (j_compress_ptr)
void term_destination (j_compress_ptr)
int write_jpeg (const unsigned char *src, int w, int h, bool ycrcb, unsigned char *dst, int &sz, int quality)
void * read_jpeg (const char *jpgbuffer, int jpgbuffer_size, bool RGB, int &output_size)
void scaleColorImage (unsigned char *src, int sw, int sh, int scx, int scy, unsigned char *dst, int dw, int dh, float sx, float sy)
int convert (const UImage &src, UImage &dest)
 Convert between various image formats, takes care of everything.
template<class S, class D>
void copy (S *src, D *dst, int sc, int dc, int sr, int dr, int count, bool sf, bool df)
int convert (const USound &source, USound &dest)
 Conversion between various sound formats.
int main (int argc, const char *argv[])
 EXTERN_STATIC_INSTANCE (UStartlist, objectlist)
 EXTERN_STATIC_INSTANCE (UStartlistHub, objecthublist)
void main (int argc, char *argv[])
 Send a binary file to the URBI server, to be saved in a variable.
void echo (const char *format,...)
 echo method
UObjectHubgetUObjectHub (const std::string &n)
 retrieve a UObjectHub based on its name
UObjectgetUObject (const std::string &n)
 retrieve a UObject based on its name
void uobject_unarmorAndSend (const char *str)
 Send URBI code (ghost connection in plugin mode, default connection in remote mode).
void send (const char *str)
 Send the string to the connection hosting the UObject.
void send (void *buf, int size)
 Send buf to the connection hosting the UObject.
const UValuecast (UValue &val, const UValue *)
UValue cast (UValue &val, UValue *)
 SETCAST (int)
 SETCAST (unsigned int)
 SETCAST (long)
 SETCAST (ufloat)
 SETCAST (std::string)
 SETCAST (bool)
 SETCAST (UImage)
 SETCAST (USound)
UVarcast (UValue &val, UVar *var)
UBinary cast (UValue &v, UBinary *b)
UList cast (UValue &v, UList *l)
UObjectStruct cast (UValue &v, UObjectStruct *o)
const char * cast (UValue &v, const char **b)
template<class I>
std::list< I > cast (UValue &val, std::list< I > *inu)
template<class R>
UGenericCallbackcreateUCallback (const std::string &objname, const std::string &type, R(*fun)(), const std::string &funname, UTable &t)
template<>
UGenericCallbackcreateUCallback (const std::string &objname, const std::string &type, void(*fun)(), const std::string &funname, UTable &t)
template<class OBJ, class R>
UGenericCallbackcreateUCallback (const std::string &objname, const std::string &type, OBJ *obj, R(OBJ::*fun)(), const std::string &funname, UTable &t)
template<class OBJ>
UGenericCallbackcreateUCallback (const std::string &objname, const std::string &type, OBJ *obj, void(OBJ::*fun)(), const std::string &funname, UTable &t)
template<class OBJ>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (const std::string &objname, const std::string &type, R(*fun)(P1), const std::string &funname, UTable &t)
template<class P1>
UGenericCallbackcreateUCallback (const std::string &objname, const std::string &type, void(*fun)(P1), const std::string &funname, UTable &t)
template<class OBJ, class R, class P1>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (const std::string &objname, const std::string &type, R(*fun)(P1, P2), const std::string &funname, UTable &t)
template<class P1, class P2>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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>
UGenericCallbackcreateUCallback (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)
bool is_blendtype (int i)
const char * name (UBlendType u)
UBlendType ublendtype (const char *cp)
bool is_propertytype (int i)
const char * name (UProperty u)
UProperty uproperty (const char *cp)
std::ostream & operator<< (std::ostream &s, const UValue &v)
void unescape (std::string &data)
void unescape (char *data)
 STATIC_INSTANCE (UStartlist, objectlist)
 STATIC_INSTANCE (UStartlistHub, objecthublist)
UCallbackAction dispatcher (const UMessage &msg)
UCallbackAction debug (const UMessage &msg)
void cleanTable (UTable &t, const std::string &name)
float ffloatpart (float a)
static char * dirname (char *src)
float fabs (float f)
int parseHeader (FILE *f, FILE *of)

Variables

static UCallbackID nextId
UClient * defaultClient = 0
UVarTable varmap
UTable functionmap
UTable eventmap
UTable eventendmap
UTable monitormap
UTable accessmap
UTimerTable timermap
UTimerTable updatemap
UObjectdummyUObject
 an empty dummy UObject used by UVar to set a NotifyChange This avoid coupling a UVar to a particular object
const char * UBlendNames []
const char * UPropertyNames []
UObjectdummyUObject
 an empty dummy UObject used by UVar to set a NotifyChange This avoid coupling a UVar to a particular object
UVarTable varmap
UTable functionmap
UTable monitormap
UTable accessmap
UTable eventmap
UTable eventendmap
UTimerTable timermap
UTimerTable updatemap
UDev * devices
int devCount


Detailed Description

Global definition of the starterlist.

Enumeration Type Documentation

enum urbi::UImageFormat

Enumerator:
IMAGE_RGB  RGB 24 bit/pixel.
IMAGE_YCbCr  YCbCr 24 bit/pixel.
IMAGE_JPEG  JPEG.
IMAGE_PPM  RGB with a PPM header.

Definition at line 37 of file ubinary.hh.


Function Documentation

int urbi::convert ( const USound &  source,
USound &  dest 
)

Conversion between various sound formats.

If any of destination's channel, sampleSize, rate or sampleFormat parameter is 0, values from source will be used. If the destination's datasize is too small, data will be realloc()ed, which means one can set data and datasize to zero, and let convert allocate the memory.

Definition at line 606 of file uconversion.cc.

References urbi::USound::channels, copy(), urbi::USound::data, urbi::USound::rate, urbi::USound::sampleFormat, urbi::USound::sampleSize, urbi::USound::size, and urbi::USound::soundFormat.

void* urbi::@20::read_jpeg ( const char *  jpgbuffer,
int  jpgbuffer_size,
bool  RGB,
int &  output_size 
) [static]

Convert a jpeg image to YCrCb or RGB. Allocate the buffer with malloc.

Definition at line 280 of file uconversion.cc.

References fill_input_buffer(), init_source(), skip_input_data(), term_source(), and urbi_jpeg_error_exit().


Variable Documentation

const char* urbi::UBlendNames[] [static]

Initial value:

    {
      "mix",
      "add",
      "discard",
      "queue",
      "cancel",
      "normal",
    }

Definition at line 42 of file utypes-common.hh.

Referenced by name(), and ublendtype().

const char* urbi::UPropertyNames[] [static]

Initial value:

    {
      "rangemin",
      "rangemax",
      "speedmin",
      "speedmax",
      "blend",
      "delta",
    }

Definition at line 96 of file utypes-common.hh.

Referenced by name(), and uproperty().


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