rlDataProvider Class Reference

#include <rldataprovider.h>

Collaboration diagram for rlDataProvider:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 rlDataProvider (int numInteger, int numFloat=0, int numString=0)
virtual ~rlDataProvider ()
int getInt (int id)
float getFloat (int id)
int getIntArray (int id, int *i, int nmax)
int getFloatArray (int id, float *f, int nmax)
const char * getString (int id)
int setInt (int id, int i)
int setFloat (int id, float f)
int setIntArray (int id, int *i, int num)
int setFloatArray (int id, float *f, int num)
int setString (int id, const char *str)
int getIntAndReset (int id)
int setIntAndWaitForReset (int id, int i)
int setInt0Semaphore (int i)
int getInt0Semaphore ()
int run (rlSocket *socket)

Private Types

typedef char * CHARPTR

Private Attributes

int * ints
float * floats
char ** strings
int num_integer
int num_float
int num_string
rlMutex mutex
rlSemaphore int0semaphore

Detailed Description

This class is a container for data.
You can get/set the data identified by id.
The run method starts a separate thread that makes rlDataProvider available over TCP.

Definition at line 29 of file rldataprovider.h.

Member Typedef Documentation

typedef char* rlDataProvider::CHARPTR [private]

Definition at line 50 of file rldataprovider.h.

Constructor & Destructor Documentation

rlDataProvider::rlDataProvider ( int  numInteger,
int  numFloat = 0,
int  numString = 0 
)

Definition at line 20 of file rldataprovider.cpp.

00021 {
00022   int i;
00023 
00024   num_integer = numInteger;
00025   num_float   = numFloat;
00026   num_string  = numString;
00027   if(num_integer < 0) num_integer = 0;
00028   if(num_float   < 0) num_float   = 0;
00029   if(num_string  < 0) num_string  = 0;
00030   ints    = NULL;
00031   floats  = NULL;
00032   strings = NULL;
00033   if(num_integer > 0)
00034   {
00035     ints = new int[num_integer];
00036     for(i=0; i<num_integer; i++) ints[i] = 0;
00037   }
00038   if(num_float > 0)
00039   {
00040     floats = new float[num_float];
00041     for(i=0; i<num_float; i++) floats[i] = 0.0f;
00042   }
00043   if(num_string > 0)
00044   {
00045     strings = new CHARPTR[num_string];
00046     for(i=0; i<num_string; i++)
00047     {
00048       strings[i] = new char [1];
00049       *strings[i] = '\0';
00050     }
00051   }
00052 }

rlDataProvider::~rlDataProvider (  )  [virtual]

Definition at line 54 of file rldataprovider.cpp.

00055 {
00056   int i;
00057 
00058   if(ints    != NULL) delete [] ints;
00059   if(floats  != NULL) delete [] floats;
00060   for(i=0; i<num_string; i++)
00061   {
00062     if(strings[i] != NULL) delete [] strings[i];
00063   }
00064   if(strings != NULL) delete [] strings;
00065 }

Member Function Documentation

float rlDataProvider::getFloat ( int  id  ) 

Definition at line 79 of file rldataprovider.cpp.

00080 {
00081   float ret;
00082 
00083   if(id < 0)          return 0.0f;
00084   if(id >= num_float) return 0.0f;
00085   mutex.lock();
00086   ret = floats[id];
00087   mutex.unlock();
00088   return ret;
00089 }

int rlDataProvider::getFloatArray ( int  id,
float *  f,
int  nmax 
)

Definition at line 116 of file rldataprovider.cpp.

00117 {
00118   int ret;
00119   const char *cptr = getString(id);
00120   if(cptr == NULL) return -1;
00121 
00122   ret = 0;
00123   while(1)
00124   {
00125     if(cptr == NULL || *cptr == '\0') break;
00126     if(*cptr != ',' && *cptr != '\"')
00127     {
00128       sscanf(cptr,"%f",&array[ret++]);
00129       cptr = strchr(cptr,',');
00130       if(cptr != NULL) cptr++;
00131       if(ret >= nmax) break;
00132     }
00133     else
00134     {
00135       cptr++;
00136     }
00137   }
00138   return ret;
00139 }

int rlDataProvider::getInt ( int  id  ) 

Definition at line 67 of file rldataprovider.cpp.

00068 {
00069   int ret;
00070 
00071   if(id < 0)            return -1;
00072   if(id >= num_integer) return -1;
00073   mutex.lock();
00074   ret = ints[id];
00075   mutex.unlock();
00076   return ret;
00077 }

int rlDataProvider::getInt0Semaphore (  ) 

Definition at line 263 of file rldataprovider.cpp.

00264 {
00265   int0semaphore.waitSemaphore();
00266   return getInt(0);
00267 }

int rlDataProvider::getIntAndReset ( int  id  ) 

Definition at line 223 of file rldataprovider.cpp.

00224 {
00225   int ret;
00226 
00227   if(id < 0)            return -1;
00228   if(id >= num_integer) return -1;
00229   mutex.lock();
00230   ret = ints[id];
00231   ints[id] = -1;
00232   mutex.unlock();
00233   return ret;
00234 }

int rlDataProvider::getIntArray ( int  id,
int *  i,
int  nmax 
)

Definition at line 91 of file rldataprovider.cpp.

00092 {
00093   int ret;
00094   const char *cptr = getString(id);
00095   if(cptr == NULL) return -1;
00096 
00097   ret = 0;
00098   while(1)
00099   {
00100     if(cptr == NULL || *cptr == '\0') break;
00101     if(*cptr != ',' && *cptr != '\"')
00102     {
00103       sscanf(cptr,"%d",&array[ret++]);
00104       cptr = strchr(cptr,',');
00105       if(cptr != NULL) cptr++;
00106       if(ret >= nmax) break;
00107     }
00108     else
00109     {
00110       cptr++;
00111     }
00112   }
00113   return ret;
00114 }

const char * rlDataProvider::getString ( int  id  ) 

Definition at line 141 of file rldataprovider.cpp.

00142 {
00143   const char *ret;
00144 
00145   if(id < 0)           return NULL;
00146   if(id >= num_string) return NULL;
00147   mutex.lock();
00148   ret = strings[id];
00149   mutex.unlock();
00150   return ret;
00151 }

int rlDataProvider::run ( rlSocket *  socket  ) 

Definition at line 269 of file rldataprovider.cpp.

00270 {
00271   int   id,ival,ret;
00272   float fval;
00273   char  cval[rl_PRINTF_LENGTH];
00274   const char *cptr;
00275   rlInterpreter interpreter;
00276 
00277   while(socket->isConnected())
00278   {
00279     ret = socket->readStr(interpreter.line,rl_PRINTF_LENGTH-1);
00280     if(ret <= 0) break;
00281     if     (interpreter.isCommand("int("))
00282     {
00283       sscanf(interpreter.line,"int(%d,%d)",&id,&ival);
00284       setInt(id,ival);
00285     }
00286     else if(interpreter.isCommand("intAndReset("))
00287     {
00288       sscanf(interpreter.line,"intAndReset(%d,%d)",&id,&ival);
00289       setIntAndWaitForReset(id,ival);
00290     }
00291     else if(interpreter.isCommand("float("))
00292     {
00293       sscanf(interpreter.line,"float(%d,%f)",&id,&fval);
00294       setFloat(id,fval);
00295     }
00296     else if(interpreter.isCommand("string("))
00297     {
00298       sscanf(interpreter.line,"string(%d,",&id);
00299       interpreter.copyStringParam(cval,0);
00300       setString(id,cval);
00301     }
00302     else if(interpreter.isCommand("getInt("))
00303     {
00304       sscanf(interpreter.line,"getInt(%d)",&id);
00305       socket->printf("intResult(%d)\n",getInt(id));
00306     }
00307     else if(interpreter.isCommand("getIntAndReset("))
00308     {
00309       sscanf(interpreter.line,"getIntAndReset(%d)",&id);
00310       socket->printf("intResult(%d)\n",getIntAndReset(id));
00311     }
00312     else if(interpreter.isCommand("getInt0Semaphore("))
00313     {
00314       socket->printf("intResult(%d)\n",getInt0Semaphore());
00315     }
00316     else if(interpreter.isCommand("getFloat("))
00317     {
00318       sscanf(interpreter.line,"getFloat(%d)",&id);
00319       socket->printf("floatResult(%f)\n",getFloat(id));
00320     }
00321     else if(interpreter.isCommand("getString("))
00322     {
00323       sscanf(interpreter.line,"getString(%d)",&id);
00324       cptr = getString(id);
00325       if(cptr == NULL) socket->printf("stringResult(\"\")\n");
00326       else             socket->printf("stringResult(\"%s\")\n",cptr);
00327     }
00328   }
00329   return 0;
00330 }

int rlDataProvider::setFloat ( int  id,
float  f 
)

Definition at line 163 of file rldataprovider.cpp.

00164 {
00165   if(id < 0)          return -1;
00166   if(id >= num_float) return -1;
00167   mutex.lock();
00168   floats[id] = f;
00169   mutex.unlock();
00170   return 0;
00171 }

int rlDataProvider::setFloatArray ( int  id,
float *  f,
int  num 
)

Definition at line 192 of file rldataprovider.cpp.

00193 {
00194   char buf[rl_PRINTF_LENGTH],val[100];
00195   int nmax,ipos,ind;
00196 
00197   if(num <= 0) return -1;
00198   nmax = rl_PRINTF_LENGTH - 1;
00199   buf[0] = '\0';
00200   ipos = strlen(buf);
00201   for(ind=0; ind<num; ind++)
00202   {
00203     sprintf(val,"%f,",array[ind]);
00204     if(ipos+(int)strlen(val) >= nmax) return -1;
00205     strcat(buf,val);
00206     ipos = strlen(buf);
00207   }
00208   return setString(id,buf);
00209 }

int rlDataProvider::setInt ( int  id,
int  i 
)

Definition at line 153 of file rldataprovider.cpp.

00154 {
00155   if(id < 0)            return -1;
00156   if(id >= num_integer) return -1;
00157   mutex.lock();
00158   ints[id] = i;
00159   mutex.unlock();
00160   return 0;
00161 }

int rlDataProvider::setInt0Semaphore ( int  i  ) 

Definition at line 254 of file rldataprovider.cpp.

00255 {
00256   int ret;
00257 
00258   ret = setInt(0,i);
00259   int0semaphore.incrementSemaphore();
00260   return ret;
00261 }

int rlDataProvider::setIntAndWaitForReset ( int  id,
int  i 
)

Definition at line 236 of file rldataprovider.cpp.

00237 {
00238   if(id < 0)            return -1;
00239   if(id >= num_integer) return -1;
00240   while(1)
00241   {
00242     mutex.lock();
00243     if(ints[id] == -1)
00244     {
00245       ints[id] = i;
00246       mutex.unlock();
00247       return 0;
00248     }
00249     mutex.unlock();
00250     rlsleep(10);
00251   }
00252 }

int rlDataProvider::setIntArray ( int  id,
int *  i,
int  num 
)

Definition at line 173 of file rldataprovider.cpp.

00174 {
00175   char buf[rl_PRINTF_LENGTH],val[100];
00176   int nmax,ipos,ind;
00177 
00178   if(num <= 0) return -1;
00179   nmax = rl_PRINTF_LENGTH - 1;
00180   buf[0] = '\0';
00181   ipos = strlen(buf);
00182   for(ind=0; ind<num; ind++)
00183   {
00184     sprintf(val,"%d,",array[ind]);
00185     if(ipos+(int)strlen(val) >= nmax) return -1;
00186     strcat(buf,val);
00187     ipos = strlen(buf);
00188   }
00189   return setString(id,buf);
00190 }

int rlDataProvider::setString ( int  id,
const char *  str 
)

Definition at line 211 of file rldataprovider.cpp.

00212 {
00213   if(id < 0)           return -1;
00214   if(id >= num_string) return -1;
00215   mutex.lock();
00216   if(strings[id] != NULL) delete [] strings[id];
00217   strings[id] = new char[strlen(str)+1];
00218   strcpy(strings[id],str);
00219   mutex.unlock();
00220   return 0;
00221 }

Member Data Documentation

float* rlDataProvider::floats [private]

Definition at line 52 of file rldataprovider.h.

rlSemaphore rlDataProvider::int0semaphore [private]

Definition at line 56 of file rldataprovider.h.

int* rlDataProvider::ints [private]

Definition at line 51 of file rldataprovider.h.

rlMutex rlDataProvider::mutex [private]

Definition at line 55 of file rldataprovider.h.

int rlDataProvider::num_float [private]

Definition at line 54 of file rldataprovider.h.

int rlDataProvider::num_integer [private]

Definition at line 54 of file rldataprovider.h.

int rlDataProvider::num_string [private]

Definition at line 54 of file rldataprovider.h.

char** rlDataProvider::strings [private]

Definition at line 53 of file rldataprovider.h.

The documentation for this class was generated from the following files:
Generated on Mon Aug 30 20:16:16 2010 for rllib by  doxygen 1.6.3