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]

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

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

00239 {
00240     for (int i = 0; i < size; i++)
00241         pack(d[i]);
00242 }

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

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

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

00224 {
00225     extendBufferFor(size*sizeof(double));
00226     STOREARRAY(double,d,size);
00227 }

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

00217 {
00218     extendBufferFor(size*sizeof(float));
00219     STOREARRAY(float,d,size);
00220 }

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

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

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

00202 {
00203     extendBufferFor(size*sizeof(long));
00204     STOREARRAY(long,d,size);
00205 }

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

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

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

00186 {
00187     extendBufferFor(size*sizeof(int));
00188     STOREARRAY(int,d,size);
00189 }

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

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

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

00170 {
00171     extendBufferFor(size*sizeof(short));
00172     STOREARRAY(short,d,size);
00173 }

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

00163 {
00164     extendBufferFor(size*sizeof(bool));
00165     STOREARRAY(bool,d,size);
00166 }

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

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

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

00149 {
00150     extendBufferFor(size*sizeof(char));
00151     STOREARRAY(char,d,size);
00152 }

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

00143 {
00144     pack(d.buffer());
00145 }

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

00135 {
00136     int len = d ? strlen(d) : 0;
00137     pack(len);
00138     extendBufferFor(len*sizeof(char));
00139     STOREARRAY(char,d,len);
00140 }

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

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

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

00120 {
00121     extendBufferFor(sizeof(double));
00122     STORE(double,d);
00123 }

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

00113 {
00114     extendBufferFor(sizeof(float));
00115     STORE(float,d);
00116 }

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

00106 {
00107     extendBufferFor(sizeof(unsigned long));
00108     STORE(unsigned long,htonl(d));
00109 }

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

00099 {
00100     extendBufferFor(sizeof(long));
00101     STORE(long,htonl(d));
00102 }

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

00092 {
00093     extendBufferFor(sizeof(unsigned int));
00094     STORE(unsigned int,htonl(d));
00095 }

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

00085 {
00086     extendBufferFor(sizeof(int));
00087     STORE(int,htonl(d));
00088 }

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

00078 {
00079     extendBufferFor(sizeof(unsigned short));
00080     STORE(unsigned short,htons(d));
00081 }

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

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

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]

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

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

00419 {
00420     for (int i = 0; i < size; i++)
00421         unpack(d[i]);
00422 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

00366 {
00367     EXTRACTARRAY(short,d,size);
00368 }

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

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

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

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

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

00349 {
00350     EXTRACTARRAY(char,d,size);
00351 }

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

00340 {
00341     int len;
00342     unpack(len);
00343     d.reserve(len+1);
00344     EXTRACTARRAY(char,d.buffer(),len);
00345     d.buffer()[len] = '\0';
00346 }

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

00330 {
00331     int len;
00332     unpack(len);
00333     char *tmp = new char[len+1];
00334     EXTRACTARRAY(char,tmp,len);
00335     tmp[len] = '\0';
00336     d = tmp;
00337 }

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

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

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

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

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

00311 {
00312     EXTRACT(float,d);
00313 }

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

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

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

00297 {
00298     EXTRACT(long,d);
00299     d = ntohl(d);
00300 }

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

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

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

00283 {
00284     EXTRACT(int,d);
00285     d = ntohl(d);
00286 }

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

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

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

00269 {
00270     EXTRACT(short,d);
00271     d = ntohs(d);
00272 }

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

00264 {
00265     EXTRACT(bool,d);
00266 }

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

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

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

00253 {
00254     EXTRACT(char,d);
00255 }


The documentation for this class was generated from the following files:
Generated on Wed Apr 4 13:37:06 2007 for ITM OverSim by  doxygen 1.4.7