nel/src/misc/mem_stream.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "stdmisc.h"
  18
  19 #include "nel/misc/mem_stream.h"
  20
  21 #ifdef DEBUG_NEW
  22         #define new DEBUG_NEW
  23 #endif
  24
  25 namespace NLMISC
  26 {
  27
  28 void CMemStream::swap(CMemStream &other)
  29 {
  30         IStream::swap(other);
  31         _Buffer.swap(other._Buffer);
  32         std::swap(_StringMode, other._StringMode);
  33         std::swap(_DefaultCapacity, other._DefaultCapacity);
  34 }
  35
  36
  37 /*
  38  * serial (inherited from IStream)
  39  */
  40 void CMemStream::serialBuffer(uint8 *buf, uint len)
  41 {
  42         // commented for optimum performance
  43 //      nlassert (len > 0);
  44
  45         if (len == 0)
  46                 return;
  47
  48         nlassert (buf != NULL);
  49
  50         if ( isReading() )
  51         {
  52                 // Check that we don't read more than there is to read
  53                 //checkStreamSize(len);
  54
  55                 uint32 pos = lengthS();
  56                 uint32 total = length();
  57                 if ( pos+len > total ) // calls virtual length (cf. sub messages)
  58                 {
  59                         throw EStreamOverflow( "CMemStream serialBuffer overflow: Read past %u bytes", total );
  60                 }
  61
  62                 // Serialize in
  63                 CFastMem::memcpy( buf, _Buffer.getBuffer().getPtr()+_Buffer.Pos, len );
  64                 _Buffer.Pos += len;
  65         }
  66         else
  67         {
  68                 // Serialize out
  69
  70                 increaseBufferIfNecessary (len);
  71                 CFastMem::memcpy( _Buffer.getBufferWrite().getPtr()+_Buffer.Pos, buf, len );
  72                 _Buffer.Pos += len;
  73
  74         }
  75 }
  76
  77 /*
  78  * serialBit (inherited from IStream)
  79  */
  80 void CMemStream::serialBit(bool &bit)
  81 {
  82         uint8 u;
  83         if ( isReading() )
  84         {
  85                 serial( u );
  86                 bit = (u!=0);
  87         }
  88         else
  89         {
  90                 u = (uint8)bit;
  91                 serial( u );
  92         }
  93 }
  94
  95
  96 /*
  97  * seek (inherited from IStream)
  98  *
  99  * Warning: in output mode, seek(end) does not point to the end of the serialized data,
 100  * but on the end of the whole allocated buffer (see size()).
 101  * If you seek back and want to return to the end of the serialized data, you have to
 102  * store the position (a better way is to use reserve()/poke()).
 103  *
 104  * Possible enhancement:
 105  * In output mode, keep another pointer to track the end of serialized data.
 106  * When serializing, increment the pointer if its value exceeds its previous value
 107  * (to prevent from an "inside serial" to increment it).
 108  * Then a seek(end) would get back to the pointer.
 109  */
 110 bool CMemStream::seek (sint32 offset, TSeekOrigin origin) const
 111 {
 112         switch (origin)
 113         {
 114         case begin:
 115                 if (offset > (sint)length())
 116                         return false;
 117                 if (offset < 0)
 118                         return false;
 119                 _Buffer.Pos = offset;
 120                 break;
 121         case current:
 122                 if (getPos ()+offset > (sint)length())
 123                         return false;
 124                 if (getPos ()+offset < 0)
 125                         return false;
 126                 _Buffer.Pos += offset;
 127                 break;
 128         case end:
 129                 if (offset < -(sint)length())
 130                         return false;
 131                 if (offset > 0)
 132                         return false;
 133                 _Buffer.Pos = _Buffer.getBuffer().size()+offset;
 134                 break;
 135         }
 136         return true;
 137 }
 138
 139
 140 /*
 141  * Resize the buffer.
 142  * Warning: the position is unchanged, only the size is changed.
 143  */
 144 void CMemStream::resize (uint32 size)
 145 {
 146         if (size == length()) return;
 147         // need to increase the buffer size
 148         _Buffer.getBufferWrite().resize(size);
 149 }
 150
 151
 152 /*
 153  * Input: read from the stream until the next separator, and return the number of bytes read. The separator is then skipped.
 154  */
 155 uint CMemStream::serialSeparatedBufferIn( uint8 *buf, uint len )
 156 {
 157         nlassert( _StringMode && isReading() );
 158
 159         // Check that we don't read more than there is to read
 160         if ( ( _Buffer.Pos == _Buffer.getBuffer().size() ) || // we are at the end
 161                  ( ( lengthS()+len+SEP_SIZE > length() ) && (_Buffer.getBuffer()[_Buffer.getBuffer().size()-1] != SEPARATOR ) ) ) // we are before the end // calls virtual length (cf. sub messages)
 162         {
 163                 throw EStreamOverflow();
 164         }
 165         // Serialize in
 166         uint32 i = 0;
 167         const uint8     *pos = _Buffer.getBuffer().getPtr()+_Buffer.Pos;
 168         while ( (i<len) && (*pos) != SEPARATOR )
 169         {
 170                 *(buf+i) = *pos;
 171                 i++;
 172                 ++pos;
 173                 ++_Buffer.Pos;
 174         }
 175         // Exceeds len
 176         if ( (*pos) != SEPARATOR )
 177         {
 178                 throw EStreamOverflow();
 179         }
 180         _Buffer.Pos += SEP_SIZE;
 181
 182         return i;
 183 }
 184
 185
 186 /*
 187  * Output: writes len bytes from buf into the stream
 188  */
 189 void CMemStream::serialSeparatedBufferOut( uint8 *buf, uint len )
 190 {
 191         nlassert( _StringMode && (!isReading()) );
 192
 193         // Serialize out
 194         uint32 oldBufferSize = _Buffer.getBuffer().size();
 195         if (_Buffer.Pos + (len + SEP_SIZE) > oldBufferSize)
 196         {
 197                 // need to increase the buffer size
 198                 _Buffer.getBufferWrite().resize(oldBufferSize*2 + len + SEP_SIZE);
 199         }
 200
 201         CFastMem::memcpy( _Buffer.getBufferWrite().getPtr()+_Buffer.Pos, buf, len );
 202         _Buffer.Pos += len;
 203         *(_Buffer.getBufferWrite().getPtr()+_Buffer.Pos) = SEPARATOR;
 204         _Buffer.Pos += SEP_SIZE;
 205
 206 }
 207
 208 /* Returns a readable string to display it to the screen. It's only for debugging purpose!
 209  * Don't use it for anything else than to debugging, the string format could change in the future.
 210  * \param hexFormat If true, display all bytes in hexadecimal, else display as chars (above 31, otherwise '.')
 211  */
 212 std::string             CMemStream::toString( bool hexFormat ) const
 213 {
 214         std::string s;
 215         uint32 len = length();
 216         if ( hexFormat )
 217         {
 218                 for ( uint i=0; i!=len; ++i )
 219                         s += NLMISC::toString( "%2X ", buffer()[i] );
 220         }
 221         else
 222         {
 223                 for ( uint i=0; i!=len; ++i )
 224                         s += NLMISC::toString( "%c", (buffer()[i]>31) ? buffer()[i] : '.' );
 225         }
 226         return s;
 227 }
 228
 229
 230 // ***************************************************************************
 231 uint                    CMemStream::getDbgStreamSize() const
 232 {
 233         if(isReading())
 234                 return length();
 235         else
 236                 return 0;
 237 }
 238
 239
 240 }