nevrax.org : docs

00001 
+00007 /* Copyright, 2000 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #include "stdmisc.h"
+00027 
+00028 #include "nel/misc/mem_stream.h"
+00029 
+00030 namespace NLMISC
+00031 {
+00032 
+00033 
+00034 /*
+00035  * Initialization constructor
+00036  */
+00037 /*CMemStream::CMemStream( bool inputStream, bool stringmode, uint32 defaultcapacity ) :
+00038         NLMISC::IStream( inputStream ), _StringMode( stringmode )
+00039 {
+00040         _Buffer.resize (std::max( defaultcapacity, (uint32)4 )); // prevent from no allocation
+00041         _BufPos = _Buffer.getPtr();
+00042 //      _Buffer.reserve( std::max( defaultcapacity, (uint32)4 ) ); // prevent from no allocation
+00043 //      _BufPos = _Buffer.begin();
+00044 }
+00045 */
+00046 
+00047 /*
+00048  * Copy constructor
+00049  */
+00050 /*CMemStream::CMemStream( const CMemStream& other ) :
+00051         IStream (other)
+00052 {
+00053         operator=( other );
+00054 }
+00055 */
+00056 
+00057 /*
+00058  * Assignment operator
+00059  */
+00060 /*CMemStream& CMemStream::operator=( const CMemStream& other )
+00061 {
+00062         IStream::operator= (other);
+00063         _Buffer = other._Buffer;
+00064         _BufPos = _Buffer.getPtr() + other.lengthS();
+00065         _StringMode = other._StringMode;
+00066         return *this;
+00067 }
+00068 */
+00069 
+00070 /*
+00071  * serial (inherited from IStream)
+00072  */
+00073 void CMemStream::serialBuffer(uint8 *buf, uint len)
+00074 {
+00075         // commented for optimum performance
+00076         nlassert (len > 0);
+00077         nlassert (buf != NULL);
+00078 
+00079         if ( isReading() )
+00080         {
+00081                 // Check that we don't read more than there is to read
+00082                 if ( lengthS()+len > lengthR() )
+00083                 {
+00084                         throw EStreamOverflow();
+00085                 }
+00086                 // Serialize in
+00087                 CFastMem::memcpy( buf, _BufPos, len );
+00088                 _BufPos += len;
+00089         }
+00090         else
+00091         {
+00092                 // Serialize out
+00093 
+00094                 increaseBufferIfNecessary (len);
+00095 /*              uint32 oldBufferSize = _Buffer.size();
+00096                 if (_BufPos - _Buffer.getPtr() + len > oldBufferSize)
+00097                 {
+00098                         // need to increase the buffer size
+00099                         uint32 pos = _BufPos - _Buffer.getPtr();
+00100                         _Buffer.resize(oldBufferSize*2 + len);
+00101                         _BufPos = _Buffer.getPtr() + pos;
+00102                 }
+00103 */
+00104                 CFastMem::memcpy( _BufPos, buf, len );
+00105                 _BufPos += len;
+00106 
+00107 /*              _Buffer.resize( size );
+00108                 _BufPos = _Buffer.end() - len;
+00109                 CFastMem::memcpy( &(*_BufPos), buf, len );
+00110                 _BufPos = _Buffer.end();*/
+00111         }
+00112 }
+00113 
+00114 /*
+00115  * serialBit (inherited from IStream)
+00116  */
+00117 void CMemStream::serialBit(bool &bit)
+00118 {
+00119 /*      if ( _StringMode )
+00120         {
+00121 */              uint8 u;
+00122                 if ( isReading() )
+00123                 {
+00124                         serial( u );
+00125                         bit = (u!=0);
+00126                 }
+00127                 else
+00128                 {
+00129                         u = (uint8)bit;
+00130                         serial( u );
+00131                 }
+00132 /*      }
+00133         else
+00134         {
+00135                 uint len = sizeof(uint8);
+00136                 uint8 thebuf;
+00137 
+00138                 if ( isReading() )
+00139                 {
+00140                         // Check that we don't read more than there is to read
+00141                         if ( lengthS()+len > lengthR() )
+00142                         {
+00143                                 throw EStreamOverflow();
+00144                         }
+00145                         // Serialize in
+00146                         memcpy( &thebuf, &(*_BufPos), len );
+00147                         _BufPos += len;
+00148                         bit = (thebuf!=0);
+00149                 }
+00150                 else
+00151                 {
+00152                         thebuf = (uint8)bit;
+00153                         // Serialize out
+00154                         _Buffer.resize( _Buffer.size() + len );
+00155                         _BufPos = _Buffer.end() - len;
+00156                         memcpy( &(*_BufPos), &thebuf, len );
+00157                         _BufPos = _Buffer.end();
+00158                 }
+00159         }*/
+00160 }
+00161 
+00162 
+00163 /*
+00164  * seek (inherited from IStream)
+00165  */
+00166 bool CMemStream::seek (sint32 offset, TSeekOrigin origin) throw(EStream)
+00167 {
+00168         switch (origin)
+00169         {
+00170         case begin:
+00171                 if (offset >= (sint)length())
+00172                         return false;
+00173                 if (offset < 0)
+00174                         return false;
+00175                 _BufPos=_Buffer.getPtr()+offset;
+00176                 break;
+00177         case current:
+00178                 if (getPos ()+offset >= (sint)length())
+00179                         return false;
+00180                 if (getPos ()+offset < 0)
+00181                         return false;
+00182                 _BufPos+=offset;
+00183                 break;
+00184         case end:
+00185                 if (offset < -(sint)length())
+00186                         return false;
+00187                 if (offset > 0)
+00188                         return false;
+00189                 _BufPos=_Buffer.getPtr()+_Buffer.size()+offset;
+00190                 break;
+00191         }
+00192         return true;
+00193 }
+00194 
+00195 
+00196 /*
+00197  * getPos (inherited from IStream)
+00198  */
+00199 /*sint32 CMemStream::getPos () throw(EStream)
+00200 {
+00201         return _BufPos - _Buffer.getPtr();
+00202 //      if (_Buffer.getPtr() == NULL)
+00203 //              return 0;
+00204 //      else
+00205 //              return (sint32)&(_BufPos[0])-(sint32)&(_Buffer[0]);
+00206 
+00207 }
+00208 */
+00209 
+00210 /*
+00211  * Clears the message
+00212  */
+00213 /*void CMemStream::clear()
+00214 {
+00215         resetPtrTable();
+00216         _Buffer.clear();
+00217         _BufPos = _Buffer.getPtr();
+00218 }
+00219 */
+00220 
+00221 void CMemStream::resize (uint32 size)
+00222 {
+00223         if (size == length()) return;
+00224         // need to increase the buffer size
+00225         uint32 pos = _BufPos - _Buffer.getPtr();
+00226         _Buffer.resize(size);
+00227         _BufPos = _Buffer.getPtr() + pos;
+00228 }
+00229 
+00230 /*
+00231  * Fills the message buffer
+00232  */
+00233 /*void CMemStream::fill( const uint8 *srcbuf, uint32 len )
+00234 {
+00235         if (len == 0) return;
+00236 
+00237         _Buffer.resize( len );
+00238         _BufPos = _Buffer.getPtr();
+00239         CFastMem::memcpy( _BufPos, srcbuf, len );
+00240 }
+00241 */
+00242 
+00243 /* EXPERIMENTAL: Returns a pointer to the message buffer for filling by an external function (use at your own risk,
+00244  * you MUST fill the number of bytes you specify in "msgsize").
+00245  * This method prevents from doing one useless buffer copy, using fill().
+00246  */
+00247 /*uint8 *CMemStream::bufferToFill( uint32 msgsize )
+00248 {
+00249         if (msgsize == 0) return NULL;
+00250 
+00251         // Same as fill() but the memcpy is done by an external function
+00252         _Buffer.resize( msgsize );
+00253         _BufPos = _Buffer.getPtr();
+00254         return _BufPos;
+00255 }
+00256 */
+00257 
+00258 /*
+00259  * Transforms the message from input to output or from output to input
+00260  */
+00261 /*void CMemStream::invert()
+00262 {
+00263         if ( isReading() )
+00264         {
+00265                 // In->Out: We want to write (serialize out) what we have read (serialized in)
+00266                 resetPtrTable();
+00267                 setInOut( false );
+00268 //              _BufPos = _Buffer.end();
+00269         }
+00270         else
+00271         {
+00272                 // Out->In: We want to read (serialize in) what we have written (serialized out)
+00273                 resetPtrTable();
+00274                 setInOut( true );
+00275                 _BufPos = _Buffer.getPtr();
+00276         }
+00277 }
+00278 */
+00279 
+00280 
+00281 
+00282 /*** String-specific methods ***/
+00283 
+00284 
+00285 //const char SEPARATOR = ' ';
+00286 //const int SEP_SIZE = 1; // the code is easier to read with that
+00287 
+00288 
+00289 
+00290 /*
+00291  * Input: read from the stream until the next separator, and return the number of bytes read. The separator is then skipped.
+00292  */
+00293 uint CMemStream::serialSeparatedBufferIn( uint8 *buf, uint len )
+00294 {
+00295         nlassert( _StringMode && isReading() );
+00296 
+00297         // Check that we don't read more than there is to read
+00298         if ( ( _BufPos == _Buffer.getPtr()+_Buffer.size() ) || // we are at the end
+00299                  ( lengthS()+len+SEP_SIZE > lengthR() ) && (_Buffer[_Buffer.size()-1] != SEPARATOR ) ) // we are before the end
+00300         {
+00301                 throw EStreamOverflow();
+00302         }
+00303         // Serialize in
+00304         uint32 i = 0;
+00305         while ( (i<len) && (*_BufPos) != SEPARATOR )
+00306         {
+00307                 *(buf+i) = *_BufPos;
+00308                 i++;
+00309                 _BufPos++;
+00310         }
+00311         // Exceeds len
+00312         if ( (*_BufPos) != SEPARATOR )
+00313         {
+00314                 throw EStreamOverflow();
+00315         }
+00316         _BufPos += SEP_SIZE;
+00317         return i;
+00318 }
+00319 
+00320 
+00321 /*
+00322  * Output: writes len bytes from buf into the stream
+00323  */
+00324 void CMemStream::serialSeparatedBufferOut( uint8 *buf, uint len )
+00325 {
+00326         nlassert( _StringMode && (!isReading()) );
+00327         
+00328         // Serialize out
+00329         uint32 oldBufferSize = _Buffer.size();
+00330         if (_BufPos - _Buffer.getPtr() + (len + SEP_SIZE) > oldBufferSize)
+00331         {
+00332                 // need to increase the buffer size
+00333                 _Buffer.resize(oldBufferSize*2 + len + SEP_SIZE);
+00334                 _BufPos = _Buffer.getPtr() + oldBufferSize;
+00335         }
+00336 
+00337         CFastMem::memcpy( _BufPos, buf, len );
+00338         _BufPos += len;
+00339         *(_BufPos++) = SEPARATOR;
+00340 
+00341         // Serialize out
+00342 /*      _Buffer.resize( _Buffer.size() + len + SEP_SIZE );
+00343         _BufPos = _Buffer.end() - len - SEP_SIZE;
+00344         CFastMem::memcpy( &(*_BufPos), buf, len );
+00345         _Buffer[_Buffer.size()-1] = SEPARATOR;
+00346         _BufPos = _Buffer.end();
+00347 */}
+00348 
+00349 /*
+00350 // Input
+00351 #define readnumber(dest,thetype,digits,convfunc) \
+00352         char number_as_cstring [digits+1]; \
+00353         uint realdigits = serialSeparatedBufferIn( (uint8*)&number_as_cstring, digits ); \
+00354         number_as_cstring[realdigits] = '\0'; \
+00355         dest = (thetype)convfunc( number_as_cstring );
+00356 
+00357 // Output
+00358 #define writenumber(src,format,digits) \
+00359         char number_as_cstring [digits+1]; \
+00360         sprintf( number_as_cstring, format, src ); \
+00361         serialSeparatedBufferOut( (uint8*)&number_as_cstring, strlen(number_as_cstring) );
+00362 */
+00363 
+00364 /*
+00365  * atoihex
+00366  */
+00367 /*inline int atoihex( const char* ident )
+00368 {
+00369         int number;
+00370         sscanf( ident, "%x", &number );
+00371         return number;
+00372 }
+00373 
+00374 inline uint32 atoui( const char *ident)
+00375 {
+00376         return (uint32) strtoul (ident, NULL, 10);
+00377 }
+00378 */
+00379 /***************************************************************/
+00380 /******************* THE FOLLOWING CODE IS COMMENTED OUT *******/
+00381 /***************************************************************
+00382 
+00383 // ======================================================================================================
+00384 void            CMemStream::serial(uint8 &b) 
+00385 {
+00386         if ( _StringMode )
+00387         {
+00388                 if ( isReading() )
+00389                 {
+00390                         readnumber( b, uint8, 3, atoi ); // 255
+00391                 }
+00392                 else
+00393                 {
+00394                         writenumber( (uint16)b,"%hu", 3 );
+00395                 }
+00396         }
+00397         else
+00398         {
+00399                 fastSerial (b);
+00400         }
+00401 }
+00402 
+00403 // ======================================================================================================
+00404 void            CMemStream::serial(sint8 &b) 
+00405 {
+00406         if ( _StringMode )
+00407         {
+00408                 if ( isReading() )
+00409                 {
+00410                         readnumber( b, sint8, 4, atoi ); // -128
+00411                 }
+00412                 else
+00413                 {
+00414                         writenumber( (sint16)b, "%hd", 4 );
+00415                 }
+00416         }
+00417         else
+00418         {
+00419                 fastSerial (b);
+00420         }
+00421 }
+00422 
+00423 // ======================================================================================================
+00424 void            CMemStream::serial(uint16 &b) 
+00425 {
+00426         if ( _StringMode )
+00427         {
+00428                 // No byte swapping in text mode
+00429                 if ( isReading() )
+00430                 {
+00431                         readnumber( b, uint16, 5, atoi ); // 65535
+00432                 }
+00433                 else
+00434                 {
+00435                         writenumber( b, "%hu", 5 );
+00436                 }
+00437         }
+00438         else
+00439         {
+00440                 fastSerial (b);
+00441         }
+00442 }
+00443 
+00444 // ======================================================================================================
+00445 void            CMemStream::serial(sint16 &b) 
+00446 {
+00447         if ( _StringMode )
+00448         {
+00449                 if ( isReading() )
+00450                 {
+00451                         readnumber( b, sint16, 6, atoi ); // -32768
+00452                 }
+00453                 else
+00454                 {
+00455                         writenumber( b, "%hd", 6 );
+00456                 }
+00457         }
+00458         else
+00459         {
+00460                 fastSerial (b);
+00461         }
+00462 }
+00463 
+00464 // ======================================================================================================
+00465 void            CMemStream::serial(uint32 &b) 
+00466 {
+00467         if ( _StringMode )
+00468         {
+00469                 if ( isReading() )
+00470                 {
+00471                         readnumber( b, uint32, 10, atoui ); // 4294967295
+00472                 }
+00473                 else
+00474                 {
+00475                         writenumber( b, "%u", 10 );
+00476                 }
+00477         }
+00478         else
+00479         {
+00480                 fastSerial (b);
+00481         }
+00482 }
+00483 
+00484 
+00485 // ======================================================================================================
+00486 void            CMemStream::serial(sint32 &b) 
+00487 {
+00488         if ( _StringMode )
+00489         {
+00490                 if ( isReading() )
+00491                 {
+00492                         readnumber( b, sint32, 11, atoi ); // -2147483648
+00493                 }
+00494                 else
+00495                 {
+00496                         writenumber( b, "%d", 11 );
+00497                 }
+00498         }
+00499         else
+00500         {
+00501                 fastSerial (b);
+00502         }
+00503 }
+00504 
+00505 // ======================================================================================================
+00506 void            CMemStream::serial(uint64 &b) 
+00507 {
+00508         if ( _StringMode )
+00509         {
+00510                 if ( isReading() )
+00511                 {
+00512                         readnumber( b, uint64, 20, atoiInt64 ); // 18446744073709551615
+00513                 }
+00514                 else
+00515                 {
+00516                         writenumber( b, "%"NL_I64"u", 20 );
+00517                 }
+00518         }
+00519         else
+00520         {
+00521                 fastSerial (b);
+00522         }
+00523 }
+00524 
+00525 // ======================================================================================================
+00526 void            CMemStream::serial(sint64 &b) 
+00527 {
+00528         if ( _StringMode )
+00529         {
+00530                 if ( isReading() )
+00531                 {
+00532                         readnumber( b, sint64, 20, atoiInt64 ); // -9223372036854775808
+00533                 }
+00534                 else
+00535                 {
+00536                         writenumber( b, "%"NL_I64"d", 20 );
+00537                 }
+00538         }
+00539         else
+00540         {
+00541                 fastSerial (b);
+00542         }
+00543 }
+00544 
+00545 // ======================================================================================================
+00546 void            CMemStream::serial(float &b) 
+00547 {
+00548         if ( _StringMode )
+00549         {
+00550                 if ( isReading() )
+00551                 {
+00552                         readnumber( b, float, 128, atof ); // ?
+00553                 }
+00554                 else
+00555                 {
+00556                         writenumber( (double)b, "%f", 128 );
+00557                 }
+00558         }
+00559         else
+00560         {
+00561                 fastSerial (b);
+00562         }
+00563 }
+00564 
+00565 // ======================================================================================================
+00566 void            CMemStream::serial(double &b) 
+00567 {
+00568         if ( _StringMode )
+00569         {
+00570                 if ( isReading() )
+00571                 {
+00572                         readnumber( b, double, 128, atof ); //
+00573                 }
+00574                 else
+00575                 {
+00576                         writenumber( b, "%f", 128 );
+00577                 }
+00578         }
+00579         else
+00580         {
+00581                 fastSerial (b);
+00582         }
+00583 }
+00584 
+00585 // ======================================================================================================
+00586 void            CMemStream::serial(bool &b) 
+00587 {
+00588         if ( _StringMode )
+00589         {
+00590                 serialBit(b);
+00591         }
+00592         else
+00593         {
+00594 #ifdef NL_LITTLE_ENDIAN
+00595                 if(isReading())
+00596                 {
+00597                         IStream::serial( b );
+00598                 }
+00599                 else
+00600                 {
+00601                         *(uint8*)_BufPos = b;
+00602                         _BufPos += sizeof(uint8);
+00603                 }
+00604 #else // NL_LITTLE_ENDIAN
+00605                 IStream::serial( b );
+00606 #endif // NL_LITTLE_ENDIAN
+00607         }
+00608 }
+00609 
+00610 
+00611 #ifndef NL_OS_CYGWIN
+00612 // ======================================================================================================
+00613 void            CMemStream::serial(char &b) 
+00614 {
+00615         if ( _StringMode )
+00616         {
+00617                 char buff [2];
+00618                 if ( isReading() )
+00619                 {
+00620                         serialBuffer( (uint8*)buff, 2 );
+00621                         b = buff[0];
+00622                 }
+00623                 else
+00624                 {
+00625                         buff[0] = b;
+00626                         buff[1] = SEPARATOR;
+00627                         serialBuffer( (uint8*)buff, 2 );
+00628                 }
+00629         }
+00630         else
+00631         {
+00632                 fastSerial (b);
+00633         }
+00634 }
+00635 #endif
+00636 
+00637 // ======================================================================================================
+00638 void            CMemStream::serial(std::string &b) 
+00639 {
+00640         if ( _StringMode )
+00641         {
+00642                 sint32  len=0;
+00643                 // Read/Write the length.
+00644                 if(isReading())
+00645                 {
+00646                         serial(len);
+00647                         nlassert( len<1000000 ); // limiting string size
+00648                         b.resize(len);
+00649                 }
+00650                 else
+00651                 {
+00652                         len= b.size();
+00653                         serial(len);
+00654                 }
+00655                 
+00656                 // Read/Write the string.
+00657                 for(sint i=0;i<len;i++)
+00658                         serialBuffer( (uint8*)&(b[i]), sizeof(b[i]) );
+00659 
+00660                 char sep = SEPARATOR;
+00661                 serialBuffer( (uint8*)&sep, 1 );
+00662         }
+00663         else
+00664         {
+00665                 IStream::serial( b );
+00666         }
+00667 }
+00668 
+00669 
+00670 // ======================================================================================================
+00671 void            CMemStream::serial(ucstring &b) 
+00672 {
+00673         if ( _StringMode )
+00674         {
+00675                 sint32  len=0;
+00676                 // Read/Write the length.
+00677                 if(isReading())
+00678                 {
+00679                         serial(len);
+00680                         b.resize(len);
+00681                 }
+00682                 else
+00683                 {
+00684                         len= b.size();
+00685                         serial(len);
+00686                 }
+00687                 // Read/Write the string.
+00688                 for(sint i=0;i<len;i++)
+00689                         serialBuffer( (uint8*)&b[i], sizeof( sizeof(b[i]) ) );
+00690 
+00691                 char sep = SEPARATOR;
+00692                 serialBuffer( (uint8*)&sep, 1 );
+00693         }
+00694         else
+00695         {
+00696                 IStream::serial( b );
+00697         }
+00698 }
+00699 
+00700 
+00701 // Specialisation of serialCont() for vector<bool>
+00702 void    CMemStream::serialCont(std::vector<bool> &cont)
+00703 {
+00704         sint32  len=0;
+00705         if(isReading())
+00706         {
+00707                 serial(len);
+00708                 // special version for vector: adjut good size.
+00709                 contReset(cont);
+00710                 cont.reserve(len);
+00711 
+00712                 for(sint i=0;i<len;i++)
+00713                 {
+00714                         bool    v;
+00715                         serial(v);
+00716                         cont.insert(cont.end(), v);
+00717                 }
+00718         }
+00719         else
+00720         {
+00721                 len= cont.size();
+00722                 serial(len);
+00723 
+00724                 std::vector<bool>::iterator it= cont.begin();
+00725                 for(sint i=0;i<len;i++, it++)
+00726                 {
+00727                         bool b = *it;
+00728                         serial( b );
+00729                 }
+00730         }
+00731 }
+00732 
+00733 
+00734 // Serialisation in hexadecimal
+00735 void    CMemStream::serialHex(uint32 &b)
+00736 {
+00737         if ( _StringMode )
+00738         {
+00739                 if ( isReading() )
+00740                 {
+00741                         readnumber( b, uint32, 10, atoihex ); // 4294967295
+00742                 }
+00743                 else
+00744                 {
+00745                         writenumber( b, "%x", 10 );
+00746                 }
+00747                 }
+00748         else
+00749         {
+00750                 IStream::serial( b );
+00751         }
+00752 }
+00753 
+00754 ***************************************************************/
+00755 }
+00756 
+00757         
+
mem_stream.cpp
