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 ( opp_string *  d,
int  size 
) [virtual]

00251 {
00252     for (int i = 0; i < size; i++)
00253         pack(d[i]);
00254 }

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

00245 {
00246     for (int i = 0; i < size; i++)
00247         pack(d[i]);
00248 }

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

00237 {
00238     extendBufferFor(size*sizeof(long double));
00239     STOREARRAY(long double,d,size);
00240 }

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

00230 {
00231     extendBufferFor(size*sizeof(double));
00232     STOREARRAY(double,d,size);
00233 }

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

00223 {
00224     extendBufferFor(size*sizeof(float));
00225     STOREARRAY(float,d,size);
00226 }

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

00216 {
00217     extendBufferFor(size*sizeof(unsigned long));
00218     STOREARRAY(unsigned long,d,size);
00219 }

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

00208 {
00209     extendBufferFor(size*sizeof(long));
00210     STOREARRAY(long,d,size);
00211 }

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

00200 {
00201     extendBufferFor(size*sizeof(unsigned int));
00202     STOREARRAY(unsigned int,d,size);
00203 }

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

00192 {
00193     extendBufferFor(size*sizeof(int));
00194     STOREARRAY(int,d,size);
00195 }

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

00184 {
00185     extendBufferFor(size*sizeof(unsigned short));
00186     STOREARRAY(unsigned short,d,size);
00187 }

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

00176 {
00177     extendBufferFor(size*sizeof(short));
00178     STOREARRAY(short,d,size);
00179 }

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

00169 {
00170     extendBufferFor(size*sizeof(bool));
00171     STOREARRAY(bool,d,size);
00172 }

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

00162 {
00163     extendBufferFor(size*sizeof(unsigned char));
00164     STOREARRAY(unsigned char,d,size);
00165 }

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

00155 {
00156     extendBufferFor(size*sizeof(char));
00157     STOREARRAY(char,d,size);
00158 }

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

00149 {
00150     pack(d.buffer());
00151 }

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

00141 {
00142     int len = d ? strlen(d) : 0;
00143     pack(len);
00144     extendBufferFor(len*sizeof(char));
00145     STOREARRAY(char,d,len);
00146 }

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

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

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

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

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

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

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 ( long  d  )  [virtual]

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

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 ( int  d  )  [virtual]

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

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 ( short  d  )  [virtual]

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

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

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

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

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

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

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

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

00431 {
00432     for (int i = 0; i < size; i++)
00433         unpack(d[i]);
00434 }

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

00425 {
00426     for (int i = 0; i < size; i++)
00427         unpack(d[i]);
00428 }

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

00420 {
00421     EXTRACTARRAY(long double,d,size);
00422 }

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

00414 {
00415     EXTRACTARRAY(double,d,size);
00416 }

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

00408 {
00409     EXTRACTARRAY(float,d,size);
00410 }

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

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

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

00396 {
00397     EXTRACTARRAY(long,d,size);
00398 }

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

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

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

00384 {
00385     EXTRACTARRAY(int,d,size);
00386 }

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

00378 {
00379     EXTRACTARRAY(unsigned short,d,size);
00380 }

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

00372 {
00373     EXTRACTARRAY(short,d,size);
00374 }

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

00367 {
00368     EXTRACTARRAY(bool,d,size);
00369 }

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

00361 {
00362     EXTRACTARRAY(unsigned char,d,size);
00363 }

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

00355 {
00356     EXTRACTARRAY(char,d,size);
00357 }

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

00346 {
00347     int len;
00348     unpack(len);
00349     d.reserve(len+1);
00350     EXTRACTARRAY(char,d.buffer(),len);
00351     d.buffer()[len] = '\0';
00352 }

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

00336 {
00337     int len;
00338     unpack(len);
00339     char *tmp = new char[len+1];
00340     EXTRACTARRAY(char,tmp,len);
00341     tmp[len] = '\0';
00342     d = tmp;
00343 }

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

00329 {
00330     EXTRACT(long double,d);
00331 }

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

00323 {
00324     EXTRACT(double,d);
00325 }

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

00317 {
00318     EXTRACT(float,d);
00319 }

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

00310 {
00311     EXTRACT(unsigned long,d);
00312     d = ntohl(d);
00313 }

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

00303 {
00304     EXTRACT(long,d);
00305     d = ntohl(d);
00306 }

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

00296 {
00297     EXTRACT(unsigned int,d);
00298     d = ntohl(d);
00299 }

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

00289 {
00290     EXTRACT(int,d);
00291     d = ntohl(d);
00292 }

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

00282 {
00283     EXTRACT(unsigned short,d);
00284     d = ntohs(d);
00285 }

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

00275 {
00276     EXTRACT(short,d);
00277     d = ntohs(d);
00278 }

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

00270 {
00271     EXTRACT(bool,d);
00272 }

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

00265 {
00266     EXTRACT(unsigned char,d);
00267 }

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

00259 {
00260     EXTRACT(char,d);
00261 }


The documentation for this class was generated from the following files:
Generated on Fri May 11 14:52:39 2007 for ITM OverSim by  doxygen 1.4.7