cNetCommBuffer Class Reference

#include <cnetcommbuffer.h>

List of all members.


Detailed Description

Communication buffer that packs data into a memory buffer without any transformation.

Public Member Functions

 cNetCommBuffer ()
 Constructor.
virtual ~cNetCommBuffer ()
 Destructor.
Pack basic types
virtual void pack (char d)
virtual void pack (unsigned char d)
virtual void pack (bool d)
virtual void pack (short d)
virtual void pack (unsigned short d)
virtual void pack (int d)
virtual void pack (unsigned int d)
virtual void pack (long d)
virtual void pack (unsigned long d)
virtual void pack (float d)
virtual void pack (double d)
virtual void pack (long double d)
virtual void pack (const char *d)
virtual void pack (opp_string &d)
Pack arrays of basic types
virtual void pack (const char *d, int size)
virtual void pack (unsigned char *d, int size)
virtual void pack (bool *d, int size)
virtual void pack (short *d, int size)
virtual void pack (unsigned short *d, int size)
virtual void pack (int *d, int size)
virtual void pack (unsigned int *d, int size)
virtual void pack (long *d, int size)
virtual void pack (unsigned long *d, int size)
virtual void pack (float *d, int size)
virtual void pack (double *d, int size)
virtual void pack (long double *d, int size)
virtual void pack (const char **d, int size)
virtual void pack (opp_string *d, int size)
Unpack basic types
virtual void unpack (char &d)
virtual void unpack (unsigned char &d)
virtual void unpack (bool &d)
virtual void unpack (short &d)
virtual void unpack (unsigned short &d)
virtual void unpack (int &d)
virtual void unpack (unsigned int &d)
virtual void unpack (long &d)
virtual void unpack (unsigned long &d)
virtual void unpack (float &d)
virtual void unpack (double &d)
virtual void unpack (long double &d)
virtual void unpack (const char *&d)
virtual void unpack (opp_string &d)
Unpack arrays of basic types
virtual void unpack (char *d, int size)
virtual void unpack (unsigned char *d, int size)
virtual void unpack (bool *d, int size)
virtual void unpack (short *d, int size)
virtual void unpack (unsigned short *d, int size)
virtual void unpack (int *d, int size)
virtual void unpack (unsigned int *d, int size)
virtual void unpack (long *d, int size)
virtual void unpack (unsigned long *d, int size)
virtual void unpack (float *d, int size)
virtual void unpack (double *d, int size)
virtual void unpack (long double *d, int size)
virtual void unpack (const char **d, int size)
virtual void unpack (opp_string *d, int size)

Constructor & Destructor Documentation

cNetCommBuffer::cNetCommBuffer (  ) 

Constructor.

00041 {
00042 }

cNetCommBuffer::~cNetCommBuffer (  )  [virtual]

Destructor.

00045 {
00046 }


Member Function Documentation

void cNetCommBuffer::pack ( char  d  )  [virtual]

00050 {
00051     extendBufferFor(sizeof(char));
00052     STORE(char,d);
00053 }

void cNetCommBuffer::pack ( unsigned char  d  )  [virtual]

00057 {
00058     extendBufferFor(sizeof(unsigned char));
00059     STORE(unsigned char,d);
00060 }

void cNetCommBuffer::pack ( bool  d  )  [virtual]

00064 {
00065     extendBufferFor(sizeof(bool));
00066     STORE(bool,d);
00067 }

void cNetCommBuffer::pack ( short  d  )  [virtual]

00071 {
00072     extendBufferFor(sizeof(short));
00073     short d_buf = htons(d);
00074     STORE(short,d_buf);
00075 }

void cNetCommBuffer::pack ( unsigned short  d  )  [virtual]

00079 {
00080     extendBufferFor(sizeof(unsigned short));
00081     unsigned short d_buf = htons(d);
00082     STORE(unsigned short,d_buf);
00083 }

void cNetCommBuffer::pack ( int  d  )  [virtual]

00087 {
00088     extendBufferFor(sizeof(int));
00089     int d_buf = htonl(d);
00090     STORE(int,d_buf);
00091 }

void cNetCommBuffer::pack ( unsigned int  d  )  [virtual]

00095 {
00096     extendBufferFor(sizeof(unsigned int));
00097     unsigned int d_buf = htonl(d);
00098     STORE(unsigned int,d_buf);
00099 }

void cNetCommBuffer::pack ( long  d  )  [virtual]

00103 {
00104     extendBufferFor(sizeof(long));
00105     long d_buf = htonl(d);
00106     STORE(long,d_buf);
00107 }

void cNetCommBuffer::pack ( unsigned long  d  )  [virtual]

00111 {
00112     extendBufferFor(sizeof(unsigned long));
00113     unsigned long d_buf = htonl(d);
00114     STORE(unsigned long,d_buf);
00115 }

void cNetCommBuffer::pack ( float  d  )  [virtual]

00119 {
00120     extendBufferFor(sizeof(float));
00121     STORE(float,d);
00122 }

void cNetCommBuffer::pack ( double  d  )  [virtual]

00126 {
00127     extendBufferFor(sizeof(double));
00128     STORE(double,d);
00129 }

void cNetCommBuffer::pack ( long double  d  )  [virtual]

00133 {
00134     extendBufferFor(sizeof(long double));
00135     STORE(long double,d);
00136 }

void cNetCommBuffer::pack ( const char *  d  )  [virtual]

00141 {
00142     int len = d ? strlen(d) : 0;
00143     // magic canary
00144     pack((uint32_t)42);
00145 
00146     pack(len);
00147     extendBufferFor(len*sizeof(char));
00148     STOREARRAY(char,d,len);
00149 }

void cNetCommBuffer::pack ( opp_string &  d  )  [virtual]

00152 {
00153     pack(d.buffer());
00154 }

void cNetCommBuffer::pack ( const char *  d,
int  size 
) [virtual]

00158 {
00159     extendBufferFor(size*sizeof(char));
00160     STOREARRAY(char,d,size);
00161 }

void cNetCommBuffer::pack ( unsigned char *  d,
int  size 
) [virtual]

00165 {
00166     extendBufferFor(size*sizeof(unsigned char));
00167     STOREARRAY(unsigned char,d,size);
00168 }

void cNetCommBuffer::pack ( bool *  d,
int  size 
) [virtual]

00172 {
00173     extendBufferFor(size*sizeof(bool));
00174     STOREARRAY(bool,d,size);
00175 }

void cNetCommBuffer::pack ( short *  d,
int  size 
) [virtual]

00179 {
00180     extendBufferFor(size*sizeof(short));
00181     STOREARRAY(short,d,size);
00182 }

void cNetCommBuffer::pack ( unsigned short *  d,
int  size 
) [virtual]

00187 {
00188     extendBufferFor(size*sizeof(unsigned short));
00189     STOREARRAY(unsigned short,d,size);
00190 }

void cNetCommBuffer::pack ( int *  d,
int  size 
) [virtual]

00195 {
00196     extendBufferFor(size*sizeof(int));
00197     STOREARRAY(int,d,size);
00198 }

void cNetCommBuffer::pack ( unsigned int *  d,
int  size 
) [virtual]

00203 {
00204     extendBufferFor(size*sizeof(unsigned int));
00205     STOREARRAY(unsigned int,d,size);
00206 }

void cNetCommBuffer::pack ( long *  d,
int  size 
) [virtual]

00211 {
00212     extendBufferFor(size*sizeof(long));
00213     STOREARRAY(long,d,size);
00214 }

void cNetCommBuffer::pack ( unsigned long *  d,
int  size 
) [virtual]

00219 {
00220     extendBufferFor(size*sizeof(unsigned long));
00221     STOREARRAY(unsigned long,d,size);
00222 }

void cNetCommBuffer::pack ( float *  d,
int  size 
) [virtual]

00226 {
00227     extendBufferFor(size*sizeof(float));
00228     STOREARRAY(float,d,size);
00229 }

void cNetCommBuffer::pack ( double *  d,
int  size 
) [virtual]

00233 {
00234     extendBufferFor(size*sizeof(double));
00235     STOREARRAY(double,d,size);
00236 }

void cNetCommBuffer::pack ( long double *  d,
int  size 
) [virtual]

00240 {
00241     extendBufferFor(size*sizeof(long double));
00242     STOREARRAY(long double,d,size);
00243 }

void cNetCommBuffer::pack ( const char **  d,
int  size 
) [virtual]

00248 {
00249     for (int i = 0; i < size; i++)
00250         pack(d[i]);
00251 }

void cNetCommBuffer::pack ( opp_string *  d,
int  size 
) [virtual]

00254 {
00255     for (int i = 0; i < size; i++)
00256         pack(d[i]);
00257 }

void cNetCommBuffer::unpack ( char &  d  )  [virtual]

00262 {
00263     EXTRACT(char,d);
00264 }

void cNetCommBuffer::unpack ( unsigned char &  d  )  [virtual]

00268 {
00269     EXTRACT(unsigned char,d);
00270 }

void cNetCommBuffer::unpack ( bool &  d  )  [virtual]

00273 {
00274     EXTRACT(bool,d);
00275 }

void cNetCommBuffer::unpack ( short &  d  )  [virtual]

00278 {
00279     EXTRACT(short,d);
00280     d = ntohs(d);
00281 }

void cNetCommBuffer::unpack ( unsigned short &  d  )  [virtual]

00285 {
00286     EXTRACT(unsigned short,d);
00287     d = ntohs(d);
00288 }

void cNetCommBuffer::unpack ( int &  d  )  [virtual]

00292 {
00293     EXTRACT(int,d);
00294     d = ntohl(d);
00295 }

void cNetCommBuffer::unpack ( unsigned int &  d  )  [virtual]

00299 {
00300     EXTRACT(unsigned int,d);
00301     d = ntohl(d);
00302 }

void cNetCommBuffer::unpack ( long &  d  )  [virtual]

00306 {
00307     EXTRACT(long,d);
00308     d = ntohl(d);
00309 }

void cNetCommBuffer::unpack ( unsigned long &  d  )  [virtual]

00313 {
00314     EXTRACT(unsigned long,d);
00315     d = ntohl(d);
00316 }

void cNetCommBuffer::unpack ( float &  d  )  [virtual]

00320 {
00321     EXTRACT(float,d);
00322 }

void cNetCommBuffer::unpack ( double &  d  )  [virtual]

00326 {
00327     EXTRACT(double,d);
00328 }

void cNetCommBuffer::unpack ( long double &  d  )  [virtual]

00332 {
00333     EXTRACT(long double,d);
00334 }

void cNetCommBuffer::unpack ( const char *&  d  )  [virtual]

00339 {
00340     uint32_t magic;
00341     unpack(magic);
00342     int len;
00343     unpack(len);
00344 
00345     if (magic != 42) len = 0;
00346 
00347     char *tmp = new char[len+1];
00348     EXTRACTARRAY(char,tmp,len);
00349     tmp[len] = '\0';
00350     d = tmp;
00351 }

void cNetCommBuffer::unpack ( opp_string &  d  )  [virtual]

00354 {
00355     uint32_t magic;
00356     unpack(magic);
00357     int len;
00358     unpack(len);
00359 
00360     if (magic != 42) len = 0;
00361 
00362     d.reserve(len+1);
00363     EXTRACTARRAY(char,d.buffer(),len);
00364     d.buffer()[len] = '\0';
00365 }

void cNetCommBuffer::unpack ( char *  d,
int  size 
) [virtual]

00368 {
00369     EXTRACTARRAY(char,d,size);
00370 }

void cNetCommBuffer::unpack ( unsigned char *  d,
int  size 
) [virtual]

00374 {
00375     EXTRACTARRAY(unsigned char,d,size);
00376 }

void cNetCommBuffer::unpack ( bool *  d,
int  size 
) [virtual]

00380 {
00381     EXTRACTARRAY(bool,d,size);
00382 }

void cNetCommBuffer::unpack ( short *  d,
int  size 
) [virtual]

00385 {
00386     EXTRACTARRAY(short,d,size);
00387 }

void cNetCommBuffer::unpack ( unsigned short *  d,
int  size 
) [virtual]

00391 {
00392     EXTRACTARRAY(unsigned short,d,size);
00393 }

void cNetCommBuffer::unpack ( int *  d,
int  size 
) [virtual]

00397 {
00398     EXTRACTARRAY(int,d,size);
00399 }

void cNetCommBuffer::unpack ( unsigned int *  d,
int  size 
) [virtual]

00403 {
00404     EXTRACTARRAY(unsigned,d,size);
00405 }

void cNetCommBuffer::unpack ( long *  d,
int  size 
) [virtual]

00409 {
00410     EXTRACTARRAY(long,d,size);
00411 }

void cNetCommBuffer::unpack ( unsigned long *  d,
int  size 
) [virtual]

00415 {
00416     EXTRACTARRAY(unsigned long,d,size);
00417 }

void cNetCommBuffer::unpack ( float *  d,
int  size 
) [virtual]

00421 {
00422     EXTRACTARRAY(float,d,size);
00423 }

void cNetCommBuffer::unpack ( double *  d,
int  size 
) [virtual]

00427 {
00428     EXTRACTARRAY(double,d,size);
00429 }

void cNetCommBuffer::unpack ( long double *  d,
int  size 
) [virtual]

00433 {
00434     EXTRACTARRAY(long double,d,size);
00435 }

void cNetCommBuffer::unpack ( const char **  d,
int  size 
) [virtual]

00438 {
00439     for (int i = 0; i < size; i++)
00440         unpack(d[i]);
00441 }

void cNetCommBuffer::unpack ( opp_string *  d,
int  size 
) [virtual]

00444 {
00445     for (int i = 0; i < size; i++)
00446         unpack(d[i]);
00447 }


The documentation for this class was generated from the following files:
Generated on Thu Apr 17 13:19:28 2008 for ITM OverSim by  doxygen 1.5.3