cnetcommbuffer.cc

Go to the documentation of this file.
00001 //=========================================================================
00002 //  CMEMCOMMBUFFER.CC - part of
00003 //
00004 //                  OMNeT++/OMNEST
00005 //           Discrete System Simulation in C++
00006 //
00007 //   Written by:  Andras Varga, 2003
00008 //
00009 //=========================================================================
00010 
00011 /*--------------------------------------------------------------*
00012   Copyright (C) 2003-2005 Andras Varga
00013   Monash University, Dept. of Electrical and Computer Systems Eng.
00014   Melbourne, Australia
00015 
00016   This file is distributed WITHOUT ANY WARRANTY. See the file
00017   `license' for details on this and other legal matters.
00018 *--------------------------------------------------------------*/
00019 #include <string.h>
00020 #include <platdep/sockets.h>
00021 #include <stdexcept>
00022 #include <omnetpp.h>
00023 #include "cnetcommbuffer.h"
00024 
00025 /*
00026 #define STORE(type,d)    {*(type *)(mBuffer+mMsgSize)=d; mMsgSize+=sizeof(type);}
00027 #define EXTRACT(type,d)  {d=*(type *)(mBuffer+mPosition); mPosition+=sizeof(type);}
00028 */
00029 
00030 #define STOREARRAY(type,d,size)   {memcpy(mBuffer+mMsgSize,d,size*sizeof(type)); mMsgSize+=size*sizeof(type);}
00031 #define EXTRACTARRAY(type,d,size) {\
00032     if ((mPosition + size*sizeof(type)) <= (uint32_t)mBufferSize) {\
00033         memcpy(d,mBuffer+mPosition,size*sizeof(type)); mPosition+=size*sizeof(type);\
00034     } else {\
00035         throw cRuntimeError("OverSim cnetcommbuffer.cc: EXTRACTARRAY buffer overflow!");\
00036     }\
00037 }
00038 
00039 #define STORE(type,d)   {memcpy(mBuffer+mMsgSize,(void*)&d,sizeof(type)); mMsgSize+=sizeof(type);}
00040 #define EXTRACT(type,d) {\
00041     if ((mPosition + sizeof(type)) <= (uint32_t)mBufferSize) {\
00042         memcpy((void*)&d,mBuffer+mPosition,sizeof(type)); mPosition+=sizeof(type);\
00043     } else {\
00044         throw cRuntimeError("OverSim cnetcommbuffer.cc: EXTRACT buffer overflow!");\
00045     }\
00046 }
00047 
00048 cNetCommBuffer::cNetCommBuffer()
00049 {
00050 }
00051 
00052 cNetCommBuffer::~cNetCommBuffer ()
00053 {
00054 }
00055 
00056 
00057 void cNetCommBuffer::pack(char d)
00058 {
00059     extendBufferFor(sizeof(char));
00060     STORE(char,d);
00061 }
00062 
00063 
00064 void cNetCommBuffer::pack(unsigned char d)
00065 {
00066     extendBufferFor(sizeof(unsigned char));
00067     STORE(unsigned char,d);
00068 }
00069 
00070 
00071 void cNetCommBuffer::pack(bool d)
00072 {
00073     extendBufferFor(sizeof(bool));
00074     STORE(bool,d);
00075 }
00076 
00077 
00078 void cNetCommBuffer::pack(short d)
00079 {
00080     extendBufferFor(sizeof(short));
00081     short d_buf = htons(d);
00082     STORE(short,d_buf);
00083 }
00084 
00085 
00086 void cNetCommBuffer::pack(unsigned short d)
00087 {
00088     extendBufferFor(sizeof(unsigned short));
00089     unsigned short d_buf = htons(d);
00090     STORE(unsigned short,d_buf);
00091 }
00092 
00093 
00094 void cNetCommBuffer::pack(int d)
00095 {
00096     extendBufferFor(sizeof(int));
00097     int d_buf = htonl(d);
00098     STORE(int,d_buf);
00099 }
00100 
00101 
00102 void cNetCommBuffer::pack(unsigned int d)
00103 {
00104     extendBufferFor(sizeof(unsigned int));
00105     unsigned int d_buf = htonl(d);
00106     STORE(unsigned int,d_buf);
00107 }
00108 
00109 
00110 void cNetCommBuffer::pack(long d)
00111 {
00112     extendBufferFor(sizeof(long));
00113     long d_buf = htonl(d);
00114     STORE(long,d_buf);
00115 }
00116 
00117 
00118 void cNetCommBuffer::pack(unsigned long d)
00119 {
00120     extendBufferFor(sizeof(unsigned long));
00121     unsigned long d_buf = htonl(d);
00122     STORE(unsigned long,d_buf);
00123 }
00124 
00125 
00126 void cNetCommBuffer::pack(opp_long_long d)
00127 {
00128     extendBufferFor(sizeof(opp_long_long));
00129     STORE(opp_long_long,d);
00130 }
00131 
00132 
00133 void cNetCommBuffer::pack(opp_unsigned_long_long d)
00134 {
00135     extendBufferFor(sizeof(opp_unsigned_long_long));
00136     STORE(opp_unsigned_long_long,d);
00137 }
00138 
00139 
00140 void cNetCommBuffer::pack(float d)
00141 {
00142     extendBufferFor(sizeof(float));
00143     STORE(float,d);
00144 }
00145 
00146 
00147 void cNetCommBuffer::pack(double d)
00148 {
00149     extendBufferFor(sizeof(double));
00150     STORE(double,d);
00151 }
00152 
00153 
00154 void cNetCommBuffer::pack(long double d)
00155 {
00156     extendBufferFor(sizeof(long double));
00157     STORE(long double,d);
00158 }
00159 
00160 
00161 
00162 // pack a string
00163 void cNetCommBuffer::pack(const char *d)
00164 {
00165     int len = d ? strlen(d) : 0;
00166 
00167     pack(len);
00168     extendBufferFor(len*sizeof(char));
00169     STOREARRAY(char,d,len);
00170 }
00171 
00172 void cNetCommBuffer::pack(const opp_string& d)
00173 {
00174     pack(d.c_str());
00175 }
00176 
00177 void cNetCommBuffer::pack(const SimTime *d, int size)
00178 {
00179     for (int i = 0; i < size; i++)
00180         pack(d[i]);
00181 }
00182 
00183 void cNetCommBuffer::pack(const char *d, int size)
00184 {
00185     extendBufferFor(size*sizeof(char));
00186     STOREARRAY(char,d,size);
00187 }
00188 
00189 
00190 void cNetCommBuffer::pack(const unsigned char *d, int size)
00191 {
00192     extendBufferFor(size*sizeof(unsigned char));
00193     STOREARRAY(unsigned char,d,size);
00194 }
00195 
00196 
00197 void cNetCommBuffer::pack(const bool *d, int size)
00198 {
00199     extendBufferFor(size*sizeof(bool));
00200     STOREARRAY(bool,d,size);
00201 }
00202 
00203 //FIXME: not portable!
00204 void cNetCommBuffer::pack(const short *d, int size)
00205 {
00206     extendBufferFor(size*sizeof(short));
00207     STOREARRAY(short,d,size);
00208 }
00209 
00210 
00211 //FIXME: not portable!
00212 void cNetCommBuffer::pack(const unsigned short *d, int size)
00213 {
00214     extendBufferFor(size*sizeof(unsigned short));
00215     STOREARRAY(unsigned short,d,size);
00216 }
00217 
00218 
00219 //FIXME: not portable!
00220 void cNetCommBuffer::pack(const int *d, int size)
00221 {
00222     extendBufferFor(size*sizeof(int));
00223     STOREARRAY(int,d,size);
00224 }
00225 
00226 
00227 //FIXME: not portable!
00228 void cNetCommBuffer::pack(const unsigned int *d, int size)
00229 {
00230     extendBufferFor(size*sizeof(unsigned int));
00231     STOREARRAY(unsigned int,d,size);
00232 }
00233 
00234 
00235 //FIXME: not portable!
00236 void cNetCommBuffer::pack(const long *d, int size)
00237 {
00238     extendBufferFor(size*sizeof(long));
00239     STOREARRAY(long,d,size);
00240 }
00241 
00242 
00243 //FIXME: not portable!
00244 void cNetCommBuffer::pack(const unsigned long *d, int size)
00245 {
00246     extendBufferFor(size*sizeof(unsigned long));
00247     STOREARRAY(unsigned long,d,size);
00248 }
00249 
00250 
00251 void cNetCommBuffer::pack(const opp_long_long *d, int size)
00252 {
00253     extendBufferFor(size*sizeof(opp_long_long));
00254     STOREARRAY(opp_long_long,d,size);
00255 }
00256 
00257 
00258 void cNetCommBuffer::pack(const opp_unsigned_long_long *d, int size)
00259 {
00260     extendBufferFor(size*sizeof(opp_unsigned_long_long));
00261     STOREARRAY(opp_unsigned_long_long,d,size);
00262 }
00263 
00264 
00265 void cNetCommBuffer::pack(const float *d, int size)
00266 {
00267     extendBufferFor(size*sizeof(float));
00268     STOREARRAY(float,d,size);
00269 }
00270 
00271 
00272 void cNetCommBuffer::pack(const double *d, int size)
00273 {
00274     extendBufferFor(size*sizeof(double));
00275     STOREARRAY(double,d,size);
00276 }
00277 
00278 
00279 void cNetCommBuffer::pack(const long double *d, int size)
00280 {
00281     extendBufferFor(size*sizeof(long double));
00282     STOREARRAY(long double,d,size);
00283 }
00284 
00285 
00286 // pack string array
00287 void cNetCommBuffer::pack(const char **d, int size)
00288 {
00289     for (int i = 0; i < size; i++)
00290         pack(d[i]);
00291 }
00292 
00293 void cNetCommBuffer::pack(const opp_string *d, int size)
00294 {
00295     for (int i = 0; i < size; i++)
00296         pack(d[i]);
00297 }
00298 
00299 void cNetCommBuffer::pack(SimTime d)
00300 {
00301     pack((opp_long_long)d.raw());
00302 }
00303 
00304 //--------------------------------
00305 
00306 void cNetCommBuffer::unpack(char& d)
00307 {
00308     EXTRACT(char,d);
00309 }
00310 
00311 
00312 void cNetCommBuffer::unpack(unsigned char& d)
00313 {
00314     EXTRACT(unsigned char,d);
00315 }
00316 
00317 void cNetCommBuffer::unpack(bool& d)
00318 {
00319     EXTRACT(bool,d);
00320 }
00321 
00322 void cNetCommBuffer::unpack(short& d)
00323 {
00324     EXTRACT(short,d);
00325     d = ntohs(d);
00326 }
00327 
00328 
00329 void cNetCommBuffer::unpack(unsigned short& d)
00330 {
00331     EXTRACT(unsigned short,d);
00332     d = ntohs(d);
00333 }
00334 
00335 
00336 void cNetCommBuffer::unpack(int& d)
00337 {
00338     EXTRACT(int,d);
00339     d = ntohl(d);
00340 }
00341 
00342 
00343 void cNetCommBuffer::unpack(unsigned int& d)
00344 {
00345     EXTRACT(unsigned int,d);
00346     d = ntohl(d);
00347 }
00348 
00349 
00350 void cNetCommBuffer::unpack(long& d)
00351 {
00352     EXTRACT(long,d);
00353     d = ntohl(d);
00354 }
00355 
00356 
00357 void cNetCommBuffer::unpack(unsigned long& d)
00358 {
00359     EXTRACT(unsigned long,d);
00360     d = ntohl(d);
00361 }
00362 
00363 
00364 void cNetCommBuffer::unpack(opp_long_long& d)
00365 {
00366     EXTRACT(opp_long_long,d);
00367 }
00368 
00369 
00370 void cNetCommBuffer::unpack(opp_unsigned_long_long& d)
00371 {
00372     EXTRACT(opp_unsigned_long_long,d);
00373 }
00374 
00375 
00376 void cNetCommBuffer::unpack(float& d)
00377 {
00378     EXTRACT(float,d);
00379 }
00380 
00381 
00382 void cNetCommBuffer::unpack(double& d)
00383 {
00384     EXTRACT(double,d);
00385 }
00386 
00387 
00388 void cNetCommBuffer::unpack(long double& d)
00389 {
00390     EXTRACT(long double,d);
00391 }
00392 
00393 
00394 // unpack a string
00395 void cNetCommBuffer::unpack(const char *&d)
00396 {
00397     int len;
00398     unpack(len);
00399 
00400     char *tmp = new char[len+1];
00401     EXTRACTARRAY(char,tmp,len);
00402     tmp[len] = '\0';
00403     d = tmp;
00404 }
00405 
00406 
00407 void cNetCommBuffer::unpack(opp_string& d)
00408 {
00409     int len;
00410     unpack(len);
00411 
00412     d.reserve(len+1);
00413     EXTRACTARRAY(char,d.buffer(),len);
00414     d.buffer()[len] = '\0';
00415 }
00416 
00417 
00418 void cNetCommBuffer::unpack(SimTime& d)
00419 {
00420     opp_long_long raw;
00421     unpack(raw);
00422     d.setRaw(raw);
00423 }
00424 
00425 
00426 void cNetCommBuffer::unpack(char *d, int size)
00427 {
00428     EXTRACTARRAY(char,d,size);
00429 }
00430 
00431 void cNetCommBuffer::unpack(unsigned char *d, int size)
00432 {
00433     EXTRACTARRAY(unsigned char,d,size);
00434 }
00435 
00436 
00437 void cNetCommBuffer::unpack(bool *d, int size)
00438 {
00439     EXTRACTARRAY(bool,d,size);
00440 }
00441 
00442 void cNetCommBuffer::unpack(short *d, int size)
00443 {
00444     EXTRACTARRAY(short,d,size);
00445 }
00446 
00447 
00448 void cNetCommBuffer::unpack(unsigned short *d, int size)
00449 {
00450     EXTRACTARRAY(unsigned short,d,size);
00451 }
00452 
00453 
00454 void cNetCommBuffer::unpack(int *d, int size)
00455 {
00456     EXTRACTARRAY(int,d,size);
00457 }
00458 
00459 
00460 void cNetCommBuffer::unpack(unsigned int *d, int size)
00461 {
00462     EXTRACTARRAY(unsigned,d,size);
00463 }
00464 
00465 
00466 void cNetCommBuffer::unpack(long *d, int size)
00467 {
00468     EXTRACTARRAY(long,d,size);
00469 }
00470 
00471 
00472 void cNetCommBuffer::unpack(unsigned long *d, int size)
00473 {
00474     EXTRACTARRAY(unsigned long,d,size);
00475 }
00476 
00477 
00478 void cNetCommBuffer::unpack(opp_long_long *d, int size)
00479 {
00480     EXTRACTARRAY(opp_long_long,d,size);
00481 }
00482 
00483 
00484 void cNetCommBuffer::unpack(opp_unsigned_long_long *d, int size)
00485 {
00486     EXTRACTARRAY(opp_unsigned_long_long,d,size);
00487 }
00488 
00489 
00490 void cNetCommBuffer::unpack(float *d, int size)
00491 {
00492     EXTRACTARRAY(float,d,size);
00493 }
00494 
00495 
00496 void cNetCommBuffer::unpack(double *d, int size)
00497 {
00498     EXTRACTARRAY(double,d,size);
00499 }
00500 
00501 
00502 void cNetCommBuffer::unpack(long double *d, int size)
00503 {
00504     EXTRACTARRAY(long double,d,size);
00505 }
00506 
00507 void cNetCommBuffer::unpack(const char **d, int size)
00508 {
00509     for (int i = 0; i < size; i++)
00510         unpack(d[i]);
00511 }
00512 
00513 void cNetCommBuffer::unpack(opp_string *d, int size)
00514 {
00515     for (int i = 0; i < size; i++)
00516         unpack(d[i]);
00517 }
00518 
00519 
00520 void cNetCommBuffer::unpack(SimTime *d, int size)
00521 {
00522     for (int i = 0; i < size; i++)
00523         unpack(d[i]);
00524 }
00525 
00526 
00527 size_t cNetCommBuffer::getRemainingMessageSize()
00528 {
00529     return (mMsgSize - mPosition);
00530 }
00531 
00532 void cNetCommBuffer::packObject(cObject *obj)
00533 {
00534     pack(obj->getClassName());
00535     obj->parsimPack(this);
00536 }
00537 
00538 cObject *cNetCommBuffer::unpackObject()
00539 {
00540     char *classname = NULL;
00541     cObject *obj = NULL;
00542     try {
00543         unpack(classname);
00544         obj = createOne(classname);
00545         obj->parsimUnpack(this);
00546     } catch (...) {
00547         delete [] classname;
00548         delete obj;
00549         throw std::invalid_argument("Failed to parse received packet");
00550     }
00551 
00552     delete [] classname;
00553     return obj;
00554 }
00555 
Generated on Wed May 26 16:21:14 2010 for OverSim by  doxygen 1.6.3