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.
size_t getRemainingMessageSize ()
 return the length of the remaining buffer in bytes
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.

00053 {
00054 }

cNetCommBuffer::~cNetCommBuffer (  )  [virtual]

Destructor.

00057 {
00058 }


Member Function Documentation

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

Referenced by pack().

00062 {
00063     extendBufferFor(sizeof(char));
00064     STORE(char,d);
00065 }

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

00069 {
00070     extendBufferFor(sizeof(unsigned char));
00071     STORE(unsigned char,d);
00072 }

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

00076 {
00077     extendBufferFor(sizeof(bool));
00078     STORE(bool,d);
00079 }

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

00083 {
00084     extendBufferFor(sizeof(short));
00085     short d_buf = htons(d);
00086     STORE(short,d_buf);
00087 }

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

00091 {
00092     extendBufferFor(sizeof(unsigned short));
00093     unsigned short d_buf = htons(d);
00094     STORE(unsigned short,d_buf);
00095 }

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

00099 {
00100     extendBufferFor(sizeof(int));
00101     int d_buf = htonl(d);
00102     STORE(int,d_buf);
00103 }

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

00107 {
00108     extendBufferFor(sizeof(unsigned int));
00109     unsigned int d_buf = htonl(d);
00110     STORE(unsigned int,d_buf);
00111 }

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

00115 {
00116     extendBufferFor(sizeof(long));
00117     long d_buf = htonl(d);
00118     STORE(long,d_buf);
00119 }

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

00123 {
00124     extendBufferFor(sizeof(unsigned long));
00125     unsigned long d_buf = htonl(d);
00126     STORE(unsigned long,d_buf);
00127 }

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

00131 {
00132     extendBufferFor(sizeof(float));
00133     STORE(float,d);
00134 }

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

00138 {
00139     extendBufferFor(sizeof(double));
00140     STORE(double,d);
00141 }

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

00145 {
00146     extendBufferFor(sizeof(long double));
00147     STORE(long double,d);
00148 }

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

00153 {
00154     int len = d ? strlen(d) : 0;
00155 
00156     pack(len);
00157     extendBufferFor(len*sizeof(char));
00158     STOREARRAY(char,d,len);
00159 }

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

00162 {
00163     pack(d.buffer());
00164 }

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

00168 {
00169     extendBufferFor(size*sizeof(char));
00170     STOREARRAY(char,d,size);
00171 }

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

00175 {
00176     extendBufferFor(size*sizeof(unsigned char));
00177     STOREARRAY(unsigned char,d,size);
00178 }

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

00182 {
00183     extendBufferFor(size*sizeof(bool));
00184     STOREARRAY(bool,d,size);
00185 }

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

00189 {
00190     extendBufferFor(size*sizeof(short));
00191     STOREARRAY(short,d,size);
00192 }

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

00197 {
00198     extendBufferFor(size*sizeof(unsigned short));
00199     STOREARRAY(unsigned short,d,size);
00200 }

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

00205 {
00206     extendBufferFor(size*sizeof(int));
00207     STOREARRAY(int,d,size);
00208 }

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

00213 {
00214     extendBufferFor(size*sizeof(unsigned int));
00215     STOREARRAY(unsigned int,d,size);
00216 }

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

00221 {
00222     extendBufferFor(size*sizeof(long));
00223     STOREARRAY(long,d,size);
00224 }

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

00229 {
00230     extendBufferFor(size*sizeof(unsigned long));
00231     STOREARRAY(unsigned long,d,size);
00232 }

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

00236 {
00237     extendBufferFor(size*sizeof(float));
00238     STOREARRAY(float,d,size);
00239 }

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

00243 {
00244     extendBufferFor(size*sizeof(double));
00245     STOREARRAY(double,d,size);
00246 }

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

00250 {
00251     extendBufferFor(size*sizeof(long double));
00252     STOREARRAY(long double,d,size);
00253 }

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

00258 {
00259     for (int i = 0; i < size; i++)
00260         pack(d[i]);
00261 }

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

00264 {
00265     for (int i = 0; i < size; i++)
00266         pack(d[i]);
00267 }

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

Referenced by unpack().

00272 {
00273     EXTRACT(char,d);
00274 }

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

00278 {
00279     EXTRACT(unsigned char,d);
00280 }

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

00283 {
00284     EXTRACT(bool,d);
00285 }

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

00288 {
00289     EXTRACT(short,d);
00290     d = ntohs(d);
00291 }

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

00295 {
00296     EXTRACT(unsigned short,d);
00297     d = ntohs(d);
00298 }

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

00302 {
00303     EXTRACT(int,d);
00304     d = ntohl(d);
00305 }

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

00309 {
00310     EXTRACT(unsigned int,d);
00311     d = ntohl(d);
00312 }

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

00316 {
00317     EXTRACT(long,d);
00318     d = ntohl(d);
00319 }

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

00323 {
00324     EXTRACT(unsigned long,d);
00325     d = ntohl(d);
00326 }

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

00330 {
00331     EXTRACT(float,d);
00332 }

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

00336 {
00337     EXTRACT(double,d);
00338 }

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

00342 {
00343     EXTRACT(long double,d);
00344 }

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

00349 {
00350     //uint32_t magic;
00351     //unpack(magic);
00352     int len;
00353     unpack(len);
00354 
00355     //if (magic != 42) len = 0;
00356 
00357     char *tmp = new char[len+1];
00358     EXTRACTARRAY(char,tmp,len);
00359     tmp[len] = '\0';
00360     d = tmp;
00361 }

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

00364 {
00365 //    uint32_t magic;
00366 //    unpack(magic);
00367     int len;
00368     unpack(len);
00369 
00370     //if (magic != 42) len = 0;
00371 
00372     d.reserve(len+1);
00373     EXTRACTARRAY(char,d.buffer(),len);
00374     d.buffer()[len] = '\0';
00375 }

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

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

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

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

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

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

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

00395 {
00396     EXTRACTARRAY(short,d,size);
00397 }

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

00401 {
00402     EXTRACTARRAY(unsigned short,d,size);
00403 }

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

00407 {
00408     EXTRACTARRAY(int,d,size);
00409 }

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

00413 {
00414     EXTRACTARRAY(unsigned,d,size);
00415 }

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

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

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

00425 {
00426     EXTRACTARRAY(unsigned long,d,size);
00427 }

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

00431 {
00432     EXTRACTARRAY(float,d,size);
00433 }

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

00437 {
00438     EXTRACTARRAY(double,d,size);
00439 }

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

00443 {
00444     EXTRACTARRAY(long double,d,size);
00445 }

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

00448 {
00449     for (int i = 0; i < size; i++)
00450         unpack(d[i]);
00451 }

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

00454 {
00455     for (int i = 0; i < size; i++)
00456         unpack(d[i]);
00457 }

size_t cNetCommBuffer::getRemainingMessageSize (  ) 

return the length of the remaining buffer in bytes

Referenced by OverSimMessage::netUnpack().

00460 {
00461     return (mMsgSize - mPosition);
00462 }


The documentation for this class was generated from the following files:

Generated on Fri Sep 19 13:05:06 2008 for ITM OverSim by  doxygen 1.5.5