From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a02271.html | 5974 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 5974 insertions(+) create mode 100644 docs/doxygen/nel/a02271.html (limited to 'docs/doxygen/nel/a02271.html') diff --git a/docs/doxygen/nel/a02271.html b/docs/doxygen/nel/a02271.html new file mode 100644 index 00000000..d82ab196 --- /dev/null +++ b/docs/doxygen/nel/a02271.html @@ -0,0 +1,5974 @@ + + +NeL: NLMISC::CMemStream class Reference + + + +

NLMISC::CMemStream Class Reference

#include <mem_stream.h> +

Inheritance diagram for NLMISC::CMemStream: +

+ + + + + + +

Detailed Description

+Memory stream.

+How output mode works: The buffer size is increased by factor 2. It means the stream can be smaller than the buffer size. The size of the stream is the current position in the stream (given by lengthS() which is equal to getPos()), because data is always written at the end (except when using poke()). About seek() particularities: see comment of the seek() method.

+buffer() ----------------------------------- getPos() ---------------- size() data already serialized out | length() = lengthS()

+How input mode works: The stream is exactly the buffer (the size is given by lengthR()). Data is read inside the stream, at the current position (given by getPos()). If you try to read data while getPos() is equal to lengthR(), you'll get an EStreamOverflow exception.

+buffer() ----------------------------------- getPos() ------------------------- size() data already serialized in data not read yet | length() = lengthR()

+CBitMemStream NLNET::CMessage

Author:: Olivier Cado, Vianney Lecroart
+Nevrax France

Date:: 2000, 2002

+ +

+Definition at line 81 of file mem_stream.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Seek fonctionnality
enum TSeekOrigin { begin, +current, +end + }
virtual std::string getStreamName () const

Public Types

Public Member Functions
const uint8 * buffer () const
uint8 * bufferToFill (uint32 msgsize)
virtual void clear ()
Clears the message.

CMemStream (const CMemStream &other)
Copy constructor.

CMemStream (bool inputStream=false, bool stringmode=false, uint32 defaultcapacity=0)
Initialization constructor.

template<class T> void fastRead (T &value)
template<class T> void fastSerial (T &val)
template<class T> void fastWrite (const T &value)
void fill (const uint8 *srcbuf, uint32 len)
sint32 getPos () const
Const and not-virtual getPos(), for direct use. Caution: should not be overloaded in a child class.

virtual sint32 getPos () throw (EStream)
void increaseBufferIfNecessary (uint32 len)
Increase the buffer size if 'len' can't enter, otherwise, do nothing.

virtual void invert ()
bool isReading () const
Is this stream a Read/Input stream?

bool isXML () const
virtual uint32 length () const
CMemStream & operator= (const CMemStream &other)
Assignment operator.

template<class T> void poke (T value, sint32 pos)
sint32 reserve (uint len)
void resetBufPos ()
void resetPtrTable ()
Force to reset the ptr table.

void resize (uint32 size)
Resize the buffer.

virtual bool seek (sint32 offset, TSeekOrigin origin) throw (EStream)
template<class T0, class T1, class T2, class T3, class T4, class T5> void serial (T0 &a, T1 &b, T2 &c, T3 &d, T4 &e, T5 &f)
template<class T0, class T1, class T2, class T3, class T4> void serial (T0 &a, T1 &b, T2 &c, T3 &d, T4 &e)
template<class T0, class T1, class T2, class T3> void serial (T0 &a, T1 &b, T2 &c, T3 &d)
template<class T0, class T1, class T2> void serial (T0 &a, T1 &b, T2 &c)
template<class T0, class T1> void serial (T0 &a, T1 &b)
template<class T> void serial (T &obj)
Template serialisation (should take the one from IStream).

virtual void serialBit (bool &bit)
Method inherited from IStream.

virtual void serialBuffer (uint8 *buf, uint len)
Method inherited from IStream.

virtual void serialBufferWithSize (uint8 *buf, uint32 len)
virtual void serialCont (std::vector< bool > &cont)
Specialisation of serialCont() for vector<bool>.

virtual void serialCont (std::vector< sint8 > &cont)
Specialisation of serialCont() for vector<sint8>.

virtual void serialCont (std::vector< uint8 > &cont)
Specialisation of serialCont() for vector<uint8>.

template<class K, class T> void serialCont (std::multimap< K, T > &cont)
Specialisation of serialCont() for vector<bool>.

template<class K, class T> void serialCont (std::map< K, T > &cont)
Specialisation of serialCont() for vector<bool>.

template<class T> void serialCont (std::multiset< T > &cont)
Specialisation of serialCont() for vector<bool>.

template<class T> void serialCont (std::set< T > &cont)
Specialisation of serialCont() for vector<bool>.

template<class T> void serialCont (std::deque< T > &cont)
Specialisation of serialCont() for vector<bool>.

template<class T> void serialCont (std::list< T > &cont)
Specialisation of serialCont() for vector<bool>.

template<class T> void serialCont (std::vector< T > &cont)
template<class T> void serialEnum (T &em)
Template enum serialisation. Serialized as a sint32.

virtual void serialMemStream (CMemStream &b)
Serial memstream, bitmemstream...

void setStringMode (bool stringmode)
Set string mode.

uint32 size () const
Returns the size of the buffer (can be greater than the length, especially in output mode).

bool stringMode () const
Return string mode.

Static Public Member Functions
void getVersionException (bool &throwOnOlder, bool &throwOnNewer)
void setVersionException (bool throwOnOlder, bool throwOnNewer)

Protected Member Functions
uint32 lengthR () const
uint32 lengthS () const
Returns the serialized length (number of bytes written or read).

template<class T> void serialVector (T &cont)

Protected Attributes
CObjectVector< uint8, false > _Buffer
uint8 * _BufPos
uint32 _DefaultCapacity
bool _StringMode
+

Member Enumeration Documentation

+ + + + +
+ + +
enum NLMISC::IStream::TSeekOrigin [inherited] +
+
+ + + + + +
+ + + +
+Parameters for seek(). begin seek from the begining of the stream. current seek from the current location of the stream pointer. end seek from the end of the stream.
Enumeration values:
+ + + + +
begin +
current +
end +
+
+ +
+Definition at line 549 of file stream.h. +
+
00549 { begin, current, end }; +

+

Constructor & Destructor Documentation

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC::CMemStream::CMemStream ( bool inputStream = false,
bool stringmode = false,
uint32 defaultcapacity = 0
) [inline]
+
+ + + + + +
+ + + +
+Initialization constructor. +
+ +
+Definition at line 86 of file mem_stream.h. +
+References _BufPos, _DefaultCapacity, _StringMode, NLMISC::CObjectVector< uint8, false >::getPtr(), NLMISC::CObjectVector< uint8, false >::resize(), and uint32. +
+
00086 : +00087 NLMISC::IStream( inputStream ), _StringMode( stringmode ) +00088 { +00089 _DefaultCapacity = std::max( defaultcapacity, (uint32)16 ); // prevent from no allocation +00090 _Buffer.resize (_DefaultCapacity); +00091 _BufPos = _Buffer.getPtr(); +00092 } + +

+

+ + + + +
+ + + + + + + + + + +
NLMISC::CMemStream::CMemStream ( const CMemStream & other ) [inline]
+
+ + + + + +
+ + + +
+Copy constructor. +
+ +
+Definition at line 95 of file mem_stream.h. +
+References operator=(). +
+
00095 : +00096 IStream (other) +00097 { +00098 operator=( other ); +00099 } + +

+

Member Function Documentation

+ + + + +
+ + + + + + + + + +
const uint8* NLMISC::CMemStream::buffer ( ) const [inline]
+
+ + + + + +
+ + + +
+Returns a pointer to the message buffer (read only) Returns NULL if the buffer is empty +
+Definition at line 238 of file mem_stream.h. +
+References NLMISC::CObjectVector< uint8, false >::getPtr(), and uint8. +
+Referenced by NLNET::CMessage::assignFromSubMessage(), NLMISC::displayBitStream(), NLNET::CMessage::extractStreamFromPos(), NLNET::TMessageRecord::serial(), NLMISC::IStream::serialMemStream(), NLMISC::CBitMemStream::serialMemStream(), and NLNET::CMessage::serialMessage(). +
+
00239 { +00240 return _Buffer.getPtr(); +00241 /* if ( _Buffer.empty() ) +00242 { +00243 return NULL; +00244 } +00245 else +00246 { +00247 return &(*_Buffer.begin()); +00248 }*/ +00249 } +

+

+ + + + +
+ + + + + + + + + + +
uint8* NLMISC::CMemStream::bufferToFill ( uint32 msgsize ) [inline]
+
+ + + + + +
+ + + +
+Resize the stream with the specified size, set the current position at the beginning of the stream and return a pointer to the stream buffer.
+Precondition: the stream is an input stream.
+Suggested usage: construct an input stream, resize and get the buffer using bufferToFillAndRead(), fill it with raw data using any filling function (warning: don't fill more than 'msgsize' bytes!), then you are ready to read, using serial(), the data you've just filled. +
+Reimplemented in NLMISC::CBitMemStream. +
+Definition at line 306 of file mem_stream.h. +
+References _BufPos, NLMISC::CObjectVector< uint8, false >::getPtr(), NLMISC::IStream::isReading(), nlassert, NLMISC::CObjectVector< uint8, false >::resize(), uint32, and uint8. +
+Referenced by NLNET::CMessage::extractStreamFromPos(), NLPACS::CGlobalRetriever::CLrLoader::run(), NLNET::TMessageRecord::serial(), NLMISC::IStream::serialMemStream(), and NLNET::CMessage::serialMessage(). +
+
00307 { +00308 #ifdef NL_DEBUG +00309 nlassert( isReading() ); +00310 #endif +00311 if ( msgsize == 0 ) +00312 return NULL; +00313 +00314 _Buffer.resize( msgsize ); +00315 _BufPos = _Buffer.getPtr(); +00316 /*if ( ! isReading() ) +00317 _BufPos += msgsize;*/ +00318 return _Buffer.getPtr(); +00319 } +

+

+ + + + +
+ + + + + + + + + + +
virtual void NLMISC::CMemStream::clear ( void ) [inline, virtual]
+
+ + + + + +
+ + + +
+Clears the message. +
+ +
+Reimplemented in NLMISC::CBitMemStream, and NLNET::CMessage. +
+Definition at line 201 of file mem_stream.h. +
+References _BufPos, _DefaultCapacity, NLMISC::CObjectVector< uint8, false >::clear(), NLMISC::CObjectVector< uint8, false >::getPtr(), NLMISC::IStream::isReading(), resetPtrTable(), and NLMISC::CObjectVector< uint8, false >::resize(). +
+Referenced by NLPACS::CGlobalRetriever::CLrLoader::run(). +
+
00202 { +00203 resetPtrTable(); +00204 _Buffer.clear(); +00205 if (!isReading()) +00206 { +00207 _Buffer.resize (_DefaultCapacity); +00208 } +00209 _BufPos = _Buffer.getPtr(); +00210 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::CMemStream::fastRead ( T & value ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 404 of file mem_stream.h. +
+References _BufPos, length(), lengthS(), and value. +
+
00405 { +00406 //nldebug( "MEMSTREAM: Reading %u-byte value in %p at pos %u", sizeof(value), this, _BufPos - _Buffer.getPtr() ); +00407 // Check that we don't read more than there is to read +00408 if ( lengthS()+sizeof(value) > length() ) // calls virtual length (cf. sub messages) +00409 { +00410 throw EStreamOverflow(); +00411 } +00412 // Serialize in +00413 value = *(T*)_BufPos; +00414 _BufPos += sizeof(value); +00415 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::CMemStream::fastSerial ( T & val ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 371 of file mem_stream.h. +
+References _BufPos, increaseBufferIfNecessary(), NLMISC::IStream::isReading(), length(), and lengthS(). +
+Referenced by serial(). +
+
00372 { +00373 #ifdef NL_LITTLE_ENDIAN +00374 if(isReading()) +00375 { +00376 // Check that we don't read more than there is to read +00377 // TODO OPTIM we can remove the check if we want to be faster (50ms->43ms for 1 million serial) +00378 if ( lengthS()+sizeof(T) > length() ) // calls virtual length (cf. sub messages) +00379 throw EStreamOverflow(); +00380 // Serialize in +00381 val = *(T*)_BufPos; +00382 } +00383 else +00384 { +00385 increaseBufferIfNecessary (sizeof(T)); +00386 *(T*)_BufPos = val; +00387 } +00388 _BufPos += sizeof (T); +00389 #else // NL_LITTLE_ENDIAN +00390 IStream::serial( val ); +00391 #endif // NL_LITTLE_ENDIAN +00392 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::CMemStream::fastWrite ( const T & value ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 395 of file mem_stream.h. +
+References _BufPos, increaseBufferIfNecessary(), and value. +
+
00396 { +00397 //nldebug( "MEMSTREAM: Writing %u-byte value in %p at pos %u", sizeof(value), this, _BufPos - _Buffer.getPtr() ); +00398 increaseBufferIfNecessary (sizeof(T)); +00399 *(T*)_BufPos = value; +00400 _BufPos += sizeof (T); +00401 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::CMemStream::fill ( const uint8 * srcbuf,
uint32 len
) [inline]
+
+ + + + + +
+ + + +
+Resize the message buffer and fill data at position 0. Input stream: the current position is set at the beginning; Output stream: the current position is set after the filled data. +
+Reimplemented in NLMISC::CBitMemStream. +
+Definition at line 277 of file mem_stream.h. +
+References _BufPos, NLMISC::CObjectVector< uint8, false >::getPtr(), NLMISC::IStream::isReading(), len, NLMISC::CObjectVector< uint8, false >::resize(), NLMISC::CObjectVector< uint8, false >::size(), uint32, and uint8. +
+Referenced by NLNET::CMessage::assignFromSubMessage(), and NL3D::CTextureMem::doGenerate(). +
+
00278 { +00279 if (len == 0) return; +00280 +00281 _Buffer.resize( len ); +00282 CFastMem::memcpy( _Buffer.getPtr(), srcbuf, len ); +00283 if (isReading()) +00284 { +00285 _BufPos = _Buffer.getPtr(); +00286 } +00287 else +00288 { +00289 _BufPos = _Buffer.getPtr() + _Buffer.size(); +00290 } +00291 } +

+

+ + + + +
+ + + + + + + + + + +
sint32 NLMISC::CMemStream::getPos ( void ) const [inline]
+
+ + + + + +
+ + + +
+Const and not-virtual getPos(), for direct use. Caution: should not be overloaded in a child class. +
+ +
+Definition at line 159 of file mem_stream.h. +
+References _BufPos, NLMISC::CObjectVector< uint8, false >::getPtr(), and sint32. +
+
00160 { +00161 return _BufPos - _Buffer.getPtr(); +00162 } +

+

+ + + + +
+ + + + + + + + + + +
virtual sint32 NLMISC::CMemStream::getPos ( void ) throw (EStream) [inline, virtual]
+
+ + + + + +
+ + + +
+Get the location of the stream pointer.
+NB: If the stream doesn't support the seek fonctionnality, it throws ESeekNotSupported. Default implementation: { throw ESeekNotSupported; }
Parameters:
+ + + +
offset is the wanted offset from the origin.
origin is the origin of the seek
+
+
Returns:
the new offset regarding from the origin.
+
See also:
ESeekNotSupported SeekOrigin seek
+ +
+Reimplemented from NLMISC::IStream. +
+Definition at line 153 of file mem_stream.h. +
+References _BufPos, NLMISC::CObjectVector< uint8, false >::getPtr(), and sint32. +
+Referenced by NLNET::CMessage::changeType(), NLNET::CMessage::CMessage(), NLNET::CMessage::getName(), NLNET::CMessage::lockSubMessage(), NLNET::CMessage::readType(), NLNET::CMessage::readTypeAtCurrentPos(), NLMISC::CBitMemStream::serial(), NLMISC::CBitMemStream::serialCont(), NLMISC::CBitMemStream::serialMemStream(), NLNET::CMessage::setType(), and NLNET::CMessage::unlockSubMessage(). +
+
00154 { +00155 return _BufPos - _Buffer.getPtr(); +00156 } +

+

+ + + + +
+ + + + + + + + + +
string NLMISC::IStream::getStreamName ( ) const [virtual, inherited]
+
+ + + + + +
+ + + +
+Get a name for this stream. maybe a fileName if FileStream. Default is to return "". +
+Reimplemented in NLMISC::CIFile, and NLMISC::COFile. +
+Definition at line 420 of file stream.cpp. +
+Referenced by NLMISC::EStream::EStream(). +
+
00421 { +00422 return ""; +00423 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::IStream::getVersionException ( bool & throwOnOlder,
bool & throwOnNewer
) [static, inherited]
+
+ + + + + +
+ + + +
+Get the behavior of IStream regarding input stream that are older/newer than the class.
See also:
serialVersion() setVersionException()
+ +
+Definition at line 78 of file stream.cpp. +
+References NLMISC::IStream::_ThrowOnNewer, and NLMISC::IStream::_ThrowOnOlder. +
+
00079 { +00080 throwOnOlder=_ThrowOnOlder; +00081 throwOnNewer=_ThrowOnNewer; +00082 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::increaseBufferIfNecessary ( uint32 len ) [inline]
+
+ + + + + +
+ + + +
+Increase the buffer size if 'len' can't enter, otherwise, do nothing. +
+ +
+Definition at line 358 of file mem_stream.h. +
+References _BufPos, NLMISC::CObjectVector< uint8, false >::getPtr(), len, NLMISC::CObjectVector< uint8, false >::resize(), NLMISC::CObjectVector< uint8, false >::size(), and uint32. +
+Referenced by fastSerial(), fastWrite(), reserve(), and serialBuffer(). +
+
00359 { +00360 uint32 oldBufferSize = _Buffer.size(); +00361 if (_BufPos - _Buffer.getPtr() + len > oldBufferSize) +00362 { +00363 // need to increase the buffer size +00364 uint32 pos = _BufPos - _Buffer.getPtr(); +00365 _Buffer.resize(oldBufferSize*2 + len); +00366 _BufPos = _Buffer.getPtr() + pos; +00367 } +00368 } +

+

+ + + + +
+ + + + + + + + + +
virtual void NLMISC::CMemStream::invert ( ) [inline, virtual]
+
+ + + + + +
+ + + +
+Transforms the message from input to output or from output to input
+Precondition:
+
If the stream is in input mode, it must not be empty (nothing filled), otherwise the position will be set to the end of the preallocated buffer (see DefaultCapacity). Postcondition:
Read->write, the position is set at the end of the stream, it is possible to add more data
+
+- Write->Read, the position is set at the beginning of the stream +
+Reimplemented in NLMISC::CBitMemStream, and NLNET::CMessage. +
+Definition at line 331 of file mem_stream.h. +
+References _BufPos, NLMISC::CObjectVector< uint8, false >::getPtr(), NLMISC::IStream::isReading(), lengthR(), resetPtrTable(), NLMISC::CObjectVector< uint8, false >::resize(), NLMISC::IStream::setInOut(), and uint32. +
+Referenced by NL3D::CParticleSystemShape::buildFromPS(), NL3D::CAnimationOptimizer::cloneTrack(), NL3D::CParticleSystemShape::flushTextures(), NL3D::CParticleSystemShape::instanciatePS(), and NLPACS::CGlobalRetriever::CLrLoader::run(). +
+
00332 { +00333 if ( isReading() ) +00334 { +00335 // In->Out: We want to write (serialize out) what we have read (serialized in) +00336 uint32 sizeOfReadStream = lengthR(); +00337 resetPtrTable(); +00338 setInOut( false ); +00339 _BufPos = _Buffer.getPtr() + sizeOfReadStream; +00340 } +00341 else +00342 { +00343 // Out->In: We want to read (serialize in) what we have written (serialized out) +00344 resetPtrTable(); +00345 setInOut( true ); +00346 _Buffer.resize (_BufPos - _Buffer.getPtr()); +00347 _BufPos = _Buffer.getPtr(); +00348 } +00349 } +

+

+ + + + +
+ + + + + + + + + +
bool NLMISC::IStream::isXML ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 221 of file stream.h. +
+References NLMISC::IStream::_XML. +
+Referenced by serial(). +
+
00221 { return _XML; } +

+

+ + + + +
+ + + + + + + + + +
virtual uint32 NLMISC::CMemStream::length ( ) const [inline, virtual]
+
+ + + + + +
+ + + +
+Returns the length (size) of the message, in bytes. If isReading(), it is the number of bytes that can be read, otherwise it is the number of bytes that have been written. +
+Reimplemented in NLMISC::CBitMemStream, and NLNET::CMessage. +
+Definition at line 217 of file mem_stream.h. +
+References NLMISC::IStream::isReading(), lengthR(), lengthS(), and uint32. +
+Referenced by fastRead(), fastSerial(), resize(), serialBuffer(), NLMISC::IStream::serialMemStream(), NLMISC::CStringStream::serialSeparatedBufferIn(), and serialSeparatedBufferIn(). +
+
00218 { +00219 if ( isReading() ) +00220 { +00221 return lengthR(); +00222 } +00223 else +00224 { +00225 return lengthS(); +00226 } +00227 } +

+

+ + + + +
+ + + + + + + + + +
uint32 NLMISC::CMemStream::lengthR ( ) const [inline, protected]
+
+ + + + + +
+ + + +
+Returns the "read" message size (number of bytes to read) Do not use directly, use length() instead in reading mode (which is virtual) +
+Reimplemented in NLNET::CMessage. +
+Definition at line 511 of file mem_stream.h. +
+References size(), and uint32. +
+Referenced by NLMISC::CBitMemStream::getSerialItem(), NLMISC::CBitMemStream::internalSerial(), invert(), length(), and NLMISC::CBitMemStream::length(). +
+
00512 { +00513 return size(); +00514 } +

+

+ + + + +
+ + + + + + + + + +
uint32 NLMISC::CMemStream::lengthS ( ) const [inline, protected]
+
+ + + + + +
+ + + +
+Returns the serialized length (number of bytes written or read). +
+ +
+Definition at line 502 of file mem_stream.h. +
+References _BufPos, NLMISC::CObjectVector< uint8, false >::getPtr(), and uint32. +
+Referenced by fastRead(), fastSerial(), NLNET::CMessage::length(), length(), NLMISC::CBitMemStream::length(), operator=(), serialBuffer(), NLMISC::CStringStream::serialSeparatedBufferIn(), and serialSeparatedBufferIn(). +
+
00503 { +00504 return _BufPos - _Buffer.getPtr(); // not calling getPos() because virtual and not const! +00505 } +

+

+ + + + +
+ + + + + + + + + + +
CMemStream& NLMISC::CMemStream::operator= ( const CMemStream & other ) [inline]
+
+ + + + + +
+ + + +
+Assignment operator. +
+ +
+Definition at line 102 of file mem_stream.h. +
+References _Buffer, _BufPos, _DefaultCapacity, _StringMode, NLMISC::CObjectVector< uint8, false >::getPtr(), and lengthS(). +
+Referenced by CMemStream(). +
+
00103 { +00104 IStream::operator= (other); +00105 _Buffer = other._Buffer; +00106 _BufPos = _Buffer.getPtr() + other.lengthS(); +00107 _StringMode = other._StringMode; +00108 _DefaultCapacity = other._DefaultCapacity; +00109 return *this; +00110 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NLMISC::CMemStream::poke ( T value,
sint32 pos
) [inline]
+
+ + + + + +
+ + + +
+When writing, fill a value previously reserved by reserve() (warning: you MUST have called reserve() with sizeof(T) before poking). Usually it's an alternative to use serialCont with a vector. Example: uint8 counter=0; sint32 counterPos = msgout.reserve( sizeof(counter) ); counter = serialSelectedItems( msgout ); msgout.poke( counter, counterPos ); +
+Definition at line 190 of file mem_stream.h. +
+References _BufPos, NLMISC::CObjectVector< uint8, false >::getPtr(), NLMISC::IStream::isReading(), nlassert, sint32, uint8, and value. +
+
00191 { +00192 if ( ! isReading() ) +00193 { +00194 uint8 *pokeBufPos = _Buffer.getPtr() + pos; +00195 nlassert( pokeBufPos + sizeof(T) <= _BufPos ); +00196 *(T*)pokeBufPos = value; +00197 } +00198 } +

+

+ + + + +
+ + + + + + + + + + +
sint32 NLMISC::CMemStream::reserve ( uint len ) [inline]
+
+ + + + + +
+ + + +
+When writing, skip 'len' bytes and return the position of the blank space for a future poke(). Warning: this has nothing to do with the semantics of reserve() in std::vector! +
+Definition at line 168 of file mem_stream.h. +
+References _BufPos, NLMISC::CObjectVector< uint8, false >::getPtr(), increaseBufferIfNecessary(), NLMISC::IStream::isReading(), len, sint32, and uint. +
+
00169 { +00170 sint32 pos = _BufPos - _Buffer.getPtr(); +00171 if ( ! isReading() ) +00172 { +00173 increaseBufferIfNecessary( len ); +00174 _BufPos += len; +00175 } +00176 return pos; +00177 } +

+

+ + + + +
+ + + + + + + + + +
void NLMISC::CMemStream::resetBufPos ( ) [inline]
+
+ + + + + +
+ + + +
+When you fill the buffer externaly (using bufferAsVector) you have to reset the BufPos calling this method
+If you are using the stream only in output mode, you can use this method as a faster version of clear() *if you don't serialize pointers*. +
+Reimplemented in NLMISC::CBitMemStream. +
+Definition at line 270 of file mem_stream.h. +
+References _BufPos, and NLMISC::CObjectVector< uint8, false >::getPtr(). +
+Referenced by NLMISC::IStream::serialMemStream(). +
+
00270 { _BufPos = _Buffer.getPtr(); } +

+

+ + + + +
+ + + + + + + + + +
void NLMISC::CMemStream::resetPtrTable ( ) [inline]
+
+ + + + + +
+ + + +
+Force to reset the ptr table. +
+ +
+Reimplemented from NLMISC::IStream. +
+Definition at line 352 of file mem_stream.h. +
+Referenced by clear(), NL3D::CParticleSystemShape::flushTextures(), NL3D::CParticleSystemShape::instanciatePS(), and invert(). +
+
00352 { IStream::resetPtrTable() ; } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::resize ( uint32 size )
+
+ + + + + +
+ + + +
+Resize the buffer. +
+ +
+Definition at line 235 of file mem_stream.cpp. +
+References _BufPos, NLMISC::CObjectVector< uint8, false >::getPtr(), length(), NLMISC::CObjectVector< uint8, false >::resize(), size, and uint32. +
+
00236 { +00237 if (size == length()) return; +00238 // need to increase the buffer size +00239 uint32 pos = _BufPos - _Buffer.getPtr(); +00240 _Buffer.resize(size); +00241 _BufPos = _Buffer.getPtr() + pos; +00242 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLMISC::CMemStream::seek ( sint32 offset,
TSeekOrigin origin
) throw (EStream) [virtual]
+
+ + + + + +
+ + + +
+Moves the stream pointer to a specified location.
+Warning: in output mode, seek(end) does not point to the end of the serialized data, but on the end of the whole allocated buffer (see size()). If you seek back and want to return to the end of the serialized data, you have to store the position (a better way is to use reserve()/poke()).
+NB: If the stream doesn't support the seek fonctionnality, it throws ESeekNotSupported. Default implementation: { throw ESeekNotSupported; }
Parameters:
+ + + +
offset is the wanted offset from the origin.
origin is the origin of the seek
+
+
Returns:
true if seek sucessfull.
+
See also:
ESeekNotSupported SeekOrigin getPos
+ +
+Reimplemented from NLMISC::IStream. +
+Definition at line 177 of file mem_stream.cpp. +
+References offset, sint, and sint32. +
+Referenced by NLNET::CMessage::changeType(), NLNET::CMessage::CMessage(), NL3D::CParticleSystemShape::flushTextures(), NLNET::CMessage::getName(), NLNET::getNameOfMessageOrTransportClass(), NL3D::CParticleSystemShape::instanciatePS(), NLNET::CMessage::readType(), NLNET::CMessage::readTypeAtCurrentPos(), NLNET::CMessage::serialMessage(), and NLNET::CMessage::unlockSubMessage(). +
+
00178 { +00179 switch (origin) +00180 { +00181 case begin: +00182 if (offset > (sint)length()) +00183 return false; +00184 if (offset < 0) +00185 return false; +00186 _BufPos=_Buffer.getPtr()+offset; +00187 break; +00188 case current: +00189 if (getPos ()+offset > (sint)length()) +00190 return false; +00191 if (getPos ()+offset < 0) +00192 return false; +00193 _BufPos+=offset; +00194 break; +00195 case end: +00196 if (offset < -(sint)length()) +00197 return false; +00198 if (offset > 0) +00199 return false; +00200 _BufPos=_Buffer.getPtr()+_Buffer.size()+offset; +00201 break; +00202 } +00203 return true; +00204 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serial ( ucstring & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 863 of file mem_stream.h. +
+References _StringMode, NLMISC::IStream::isReading(), len, NLMISC::SEPARATOR, serial(), serialBuffer(), sint, sint32, and uint8. +
+
00864 { +00865 if ( _StringMode ) +00866 { +00867 sint32 len=0; +00868 // Read/Write the length. +00869 if(isReading()) +00870 { +00871 serial(len); +00872 b.resize(len); +00873 } +00874 else +00875 { +00876 len= b.size(); +00877 serial(len); +00878 } +00879 // Read/Write the string. +00880 for(sint i=0;i<len;i++) +00881 serialBuffer( (uint8*)&b[i], sizeof( sizeof(b[i]) ) ); +00882 +00883 char sep = SEPARATOR; +00884 serialBuffer( (uint8*)&sep, 1 ); +00885 } +00886 else +00887 { +00888 IStream::serial( b ); +00889 } +00890 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serial ( std::string & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 803 of file mem_stream.h. +
+References _StringMode, fastSerial(), NLMISC::IStream::isReading(), NLMISC::IStream::isXML(), len, nlassert, nlwarning, NLMISC::SEPARATOR, serial(), serialBuffer(), sint, sint32, and uint8. +
+
00804 { +00805 if ( _StringMode ) +00806 { +00807 sint32 len=0; +00808 // Read/Write the length. +00809 if(isReading()) +00810 { +00811 serial(len); +00812 nlassert( len<1000000 ); // limiting string size +00813 b.resize(len); +00814 } +00815 else +00816 { +00817 len= b.size(); +00818 serial(len); +00819 } +00820 +00821 // Read/Write the string. +00822 for(sint i=0;i<len;i++) +00823 serialBuffer( (uint8*)&(b[i]), sizeof(b[i]) ); +00824 +00825 char sep = SEPARATOR; +00826 serialBuffer( (uint8*)&sep, 1 ); +00827 } +00828 else +00829 { +00830 if (isReading()) +00831 { +00832 if (sizeof(char) == 1 && !isXML()) +00833 { +00834 sint32 len=0; +00835 fastSerial(len); +00836 // nlassert( len<1000000 ); // limiting string size +00837 if (len>1000000) +00838 { +00839 nlwarning("Trying to serialize a string of %u character !", len); +00840 throw NLMISC::EStreamOverflow(); +00841 } +00842 b.resize(len); +00843 if (len > 0) +00844 { +00845 // can serial all in a single call to serialBuffer, since sizeof(char) == 1 +00846 serialBuffer((uint8 *) &b[0], len); +00847 } +00848 } +00849 else +00850 { +00851 IStream::serial( b ); +00852 } +00853 } +00854 else +00855 { +00856 IStream::serial( b ); +00857 } +00858 } +00859 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serial ( char & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 778 of file mem_stream.h. +
+References _StringMode, fastSerial(), NLMISC::IStream::isReading(), NLMISC::SEPARATOR, serialBuffer(), and uint8. +
+
00779 { +00780 if ( _StringMode ) +00781 { +00782 char buff [2]; +00783 if ( isReading() ) +00784 { +00785 serialBuffer( (uint8*)buff, 2 ); +00786 b = buff[0]; +00787 } +00788 else +00789 { +00790 buff[0] = b; +00791 buff[1] = SEPARATOR; +00792 serialBuffer( (uint8*)buff, 2 ); +00793 } +00794 } +00795 else +00796 { +00797 fastSerial (b); +00798 } +00799 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serial ( bool & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 763 of file mem_stream.h. +
+References _StringMode, fastSerial(), and serialBit(). +
+
00764 { +00765 if ( _StringMode ) +00766 { +00767 serialBit(b); +00768 } +00769 else +00770 { +00771 fastSerial (b); +00772 } +00773 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serial ( double & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 743 of file mem_stream.h. +
+References _StringMode, fastSerial(), NLMISC::IStream::isReading(), readnumber, and writenumber. +
+
00744 { +00745 if ( _StringMode ) +00746 { +00747 if ( isReading() ) +00748 { +00749 readnumber( b, double, 128, atof ); // +00750 } +00751 else +00752 { +00753 writenumber( b, "%f", 128 ); +00754 } +00755 } +00756 else +00757 { +00758 fastSerial (b); +00759 } +00760 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serial ( float & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 723 of file mem_stream.h. +
+References _StringMode, fastSerial(), NLMISC::IStream::isReading(), readnumber, and writenumber. +
+
00724 { +00725 if ( _StringMode ) +00726 { +00727 if ( isReading() ) +00728 { +00729 readnumber( b, float, 128, atof ); // ? +00730 } +00731 else +00732 { +00733 writenumber( (double)b, "%f", 128 ); +00734 } +00735 } +00736 else +00737 { +00738 fastSerial (b); +00739 } +00740 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serial ( sint64 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 703 of file mem_stream.h. +
+References _StringMode, fastSerial(), NLMISC::IStream::isReading(), NL_I64, readnumber, sint64, and writenumber. +
+
00704 { +00705 if ( _StringMode ) +00706 { +00707 if ( isReading() ) +00708 { +00709 readnumber( b, sint64, 20, atoiInt64 ); // -9223372036854775808 +00710 } +00711 else +00712 { +00713 writenumber( b, "%"NL_I64"d", 20 ); +00714 } +00715 } +00716 else +00717 { +00718 fastSerial (b); +00719 } +00720 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serial ( uint64 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 683 of file mem_stream.h. +
+References _StringMode, fastSerial(), NLMISC::IStream::isReading(), NL_I64, readnumber, uint64, and writenumber. +
+
00684 { +00685 if ( _StringMode ) +00686 { +00687 if ( isReading() ) +00688 { +00689 readnumber( b, uint64, 20, atoiInt64 ); // 18446744073709551615 +00690 } +00691 else +00692 { +00693 writenumber( b, "%"NL_I64"u", 20 ); +00694 } +00695 } +00696 else +00697 { +00698 fastSerial (b); +00699 } +00700 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serial ( sint32 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 663 of file mem_stream.h. +
+References _StringMode, fastSerial(), NLMISC::IStream::isReading(), readnumber, sint32, and writenumber. +
+
00664 { +00665 if ( _StringMode ) +00666 { +00667 if ( isReading() ) +00668 { +00669 readnumber( b, sint32, 11, atoi ); // -2147483648 +00670 } +00671 else +00672 { +00673 writenumber( b, "%d", 11 ); +00674 } +00675 } +00676 else +00677 { +00678 fastSerial (b); +00679 } +00680 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serial ( uint32 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 642 of file mem_stream.h. +
+References _StringMode, NLMISC::atoui(), fastSerial(), NLMISC::IStream::isReading(), readnumber, uint32, and writenumber. +
+
00643 { +00644 if ( _StringMode ) +00645 { +00646 if ( isReading() ) +00647 { +00648 readnumber( b, uint32, 10, atoui ); // 4294967295 +00649 } +00650 else +00651 { +00652 writenumber( b, "%u", 10 ); +00653 } +00654 } +00655 else +00656 { +00657 fastSerial (b); +00658 } +00659 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serial ( sint16 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 622 of file mem_stream.h. +
+References _StringMode, fastSerial(), NLMISC::IStream::isReading(), readnumber, sint16, and writenumber. +
+
00623 { +00624 if ( _StringMode ) +00625 { +00626 if ( isReading() ) +00627 { +00628 readnumber( b, sint16, 6, atoi ); // -32768 +00629 } +00630 else +00631 { +00632 writenumber( b, "%hd", 6 ); +00633 } +00634 } +00635 else +00636 { +00637 fastSerial (b); +00638 } +00639 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serial ( uint16 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 601 of file mem_stream.h. +
+References _StringMode, fastSerial(), NLMISC::IStream::isReading(), readnumber, uint16, and writenumber. +
+
00602 { +00603 if ( _StringMode ) +00604 { +00605 // No byte swapping in text mode +00606 if ( isReading() ) +00607 { +00608 readnumber( b, uint16, 5, atoi ); // 65535 +00609 } +00610 else +00611 { +00612 writenumber( b, "%hu", 5 ); +00613 } +00614 } +00615 else +00616 { +00617 fastSerial (b); +00618 } +00619 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serial ( sint8 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 581 of file mem_stream.h. +
+References _StringMode, fastSerial(), NLMISC::IStream::isReading(), readnumber, sint16, sint8, and writenumber. +
+
00582 { +00583 if ( _StringMode ) +00584 { +00585 if ( isReading() ) +00586 { +00587 readnumber( b, sint8, 4, atoi ); // -128 +00588 } +00589 else +00590 { +00591 writenumber( (sint16)b, "%hd", 4 ); +00592 } +00593 } +00594 else +00595 { +00596 fastSerial (b); +00597 } +00598 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serial ( uint8 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 561 of file mem_stream.h. +
+References _StringMode, fastSerial(), NLMISC::IStream::isReading(), readnumber, uint16, uint8, and writenumber. +
+
00562 { +00563 if ( _StringMode ) +00564 { +00565 if ( isReading() ) +00566 { +00567 readnumber( b, uint8, 3, atoi ); // 255 +00568 } +00569 else +00570 { +00571 writenumber( (uint16)b,"%hu", 3 ); +00572 } +00573 } +00574 else +00575 { +00576 fastSerial (b); +00577 } +00578 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T0, class T1, class T2, class T3, class T4, class T5>
void NLMISC::CMemStream::serial ( T0 & a,
T1 & b,
T2 & c,
T3 & d,
T4 & e,
T5 & f
) [inline]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CStringStream. +
+Definition at line 459 of file mem_stream.h. +
+References serial(). +
+
00460 { serial(a); serial(b); serial(c); serial(d); serial(e); serial(f);} +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T0, class T1, class T2, class T3, class T4>
void NLMISC::CMemStream::serial ( T0 & a,
T1 & b,
T2 & c,
T3 & d,
T4 & e
) [inline]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CStringStream. +
+Definition at line 456 of file mem_stream.h. +
+References serial(). +
+
00457 { serial(a); serial(b); serial(c); serial(d); serial(e);} +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T0, class T1, class T2, class T3>
void NLMISC::CMemStream::serial ( T0 & a,
T1 & b,
T2 & c,
T3 & d
) [inline]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CStringStream. +
+Definition at line 453 of file mem_stream.h. +
+References serial(). +
+
00454 { serial(a); serial(b); serial(c); serial(d);} +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T0, class T1, class T2>
void NLMISC::CMemStream::serial ( T0 & a,
T1 & b,
T2 & c
) [inline]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CStringStream. +
+Definition at line 450 of file mem_stream.h. +
+References serial(). +
+
00451 { serial(a); serial(b); serial(c);} +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + +
+template<class T0, class T1>
void NLMISC::CMemStream::serial ( T0 & a,
T1 & b
) [inline]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CStringStream. +
+Definition at line 447 of file mem_stream.h. +
+References serial(). +
+
00448 { serial(a); serial(b);} +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serialBit ( bool & bit ) [virtual]
+
+ + + + + +
+ + + +
+Method inherited from IStream. +
+ +
+Implements NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 117 of file mem_stream.cpp. +
+References NLMISC::IStream::isReading(), serial(), and uint8. +
+Referenced by serial(). +
+
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 > length() ) // calls virtual length (cf. sub messages) +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 } +

+

+ + + + +
+ + + + + + + + + + +
uint16 NLMISC::IStream::serialBitField16 ( uint16 bf ) [inline, inherited]
+
+ + + + + +
+ + + +
+Serialisation of bitfield <=16 bits. +
+ +
+Definition at line 332 of file stream_inline.h. +
+References NLMISC::IStream::serial(), and uint16. +
+
00333 { +00334 serial(bf); +00335 return bf; +00336 } +

+

+ + + + +
+ + + + + + + + + + +
uint32 NLMISC::IStream::serialBitField32 ( uint32 bf ) [inline, inherited]
+
+ + + + + +
+ + + +
+Serialisation of bitfield <=32 bits. +
+ +
+Definition at line 338 of file stream_inline.h. +
+References NLMISC::IStream::serial(), and uint32. +
+
00339 { +00340 serial(bf); +00341 return bf; +00342 } +

+

+ + + + +
+ + + + + + + + + + +
uint8 NLMISC::IStream::serialBitField8 ( uint8 bf ) [inline, inherited]
+
+ + + + + +
+ + + +
+Serialisation of bitfield <=8 bits. +
+ +
+Definition at line 326 of file stream_inline.h. +
+References NLMISC::IStream::serial(), and uint8. +
+Referenced by NL3D::CMaterial::CTexEnv::serial(). +
+
00327 { +00328 serial(bf); +00329 return bf; +00330 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::CMemStream::serialBuffer ( uint8 * buf,
uint len
) [virtual]
+
+ + + + + +
+ + + +
+Method inherited from IStream. +
+ +
+Implements NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream. +
+Definition at line 73 of file mem_stream.cpp. +
+References _BufPos, increaseBufferIfNecessary(), NLMISC::IStream::isReading(), len, length(), lengthS(), nlassert, uint, and uint8. +
+Referenced by NLMISC::CStringStream::serial(), NLNET::TMessageRecord::serial(), serial(), and NLNET::CMessage::serialMessage(). +
+
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 > length() ) // calls virtual length (cf. sub messages) +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 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
virtual void NLMISC::IStream::serialBufferWithSize ( uint8 * buf,
uint32 len
) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+This method first serializes the size of the buffer and after the buffer itself, it enables the possibility to serial with a serialCont() on the other side. +
+Definition at line 877 of file stream.h. +
+References len, NLMISC::IStream::serial(), NLMISC::IStream::serialBuffer(), uint32, and uint8. +
+
00878 { +00879 serial (len); +00880 serialBuffer (buf, len); +00881 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialCheck ( const T & value ) [inline, inherited]
+
+ + + + + +
+ + + +
+Serialize a check value. An object can stream a check value to check integrity or format of filed or streamed data. Just call serial check with a const value. Write will serial the value. Read will check the value is the same. If it is not, it will throw EInvalidDataStream exception.
+NB: The type of the value must implement an operator == and must be serializable.
Parameters:
+ + +
value the value used to the check.
+
+
See also:
EInvalidDataStream
+ +
+Definition at line 520 of file stream.h. +
+References NLMISC::IStream::isReading(), NLMISC::IStream::serial(), value, NLMISC::IStream::xmlPop(), and NLMISC::IStream::xmlPush(). +
+Referenced by NLNET::cbPacsAnswer(), NLNET::CPacsClient::initMessage(), loadForm(), NLLIGO::CZoneRegion::serial(), NLLIGO::CZoneBankElement::serial(), NL3D::CZone::serial(), NL3D::CVegetableShape::serial(), NL3D::CSkeletonWeight::serial(), NL3D::CInstanceGroup::serial(), NL3D::CLodCharacterShape::serial(), NL3D::CLodCharacterShapeBuild::serial(), NL3D::CAnimationSet::serial(), and NL3D::CAnimation::serial(). +
+
00521 { +00522 // Open a node +00523 xmlPush ("CHECK"); +00524 +00525 if (isReading()) +00526 { +00527 T read; +00528 serial (read); +00529 if (read!=value) +00530 throw EInvalidDataStream(*this); +00531 } +00532 else +00533 { +00534 serial (const_cast<T&>(value)); +00535 } +00536 +00537 // Close the node +00538 xmlPop (); +00539 } +

+

+ + + + +
+ + + + + + + + + + +
virtual void NLMISC::CMemStream::serialCont ( std::vector< bool > & cont ) [inline, virtual]
+
+ + + + + +
+ + + +
+Specialisation of serialCont() for vector<bool>. +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 442 of file mem_stream.h. +
+
00442 {IStream::serialCont(cont);} +

+

+ + + + +
+ + + + + + + + + + +
virtual void NLMISC::CMemStream::serialCont ( std::vector< sint8 > & cont ) [inline, virtual]
+
+ + + + + +
+ + + +
+Specialisation of serialCont() for vector<sint8>. +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 440 of file mem_stream.h. +
+
00440 {IStream::serialCont(cont);} +

+

+ + + + +
+ + + + + + + + + + +
virtual void NLMISC::CMemStream::serialCont ( std::vector< uint8 > & cont ) [inline, virtual]
+
+ + + + + +
+ + + +
+Specialisation of serialCont() for vector<uint8>. +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 438 of file mem_stream.h. +
+
00438 {IStream::serialCont(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class K, class T>
void NLMISC::CMemStream::serialCont ( std::multimap< K, T > & cont ) [inline]
+
+ + + + + +
+ + + +
+Specialisation of serialCont() for vector<bool>. +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 435 of file mem_stream.h. +
+
00435 {IStream::serialCont(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class K, class T>
void NLMISC::CMemStream::serialCont ( std::map< K, T > & cont ) [inline]
+
+ + + + + +
+ + + +
+Specialisation of serialCont() for vector<bool>. +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 433 of file mem_stream.h. +
+
00433 {IStream::serialCont(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::CMemStream::serialCont ( std::multiset< T > & cont ) [inline]
+
+ + + + + +
+ + + +
+Specialisation of serialCont() for vector<bool>. +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 431 of file mem_stream.h. +
+
00431 {IStream::serialCont(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::CMemStream::serialCont ( std::set< T > & cont ) [inline]
+
+ + + + + +
+ + + +
+Specialisation of serialCont() for vector<bool>. +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 429 of file mem_stream.h. +
+
00429 {IStream::serialCont(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::CMemStream::serialCont ( std::deque< T > & cont ) [inline]
+
+ + + + + +
+ + + +
+Specialisation of serialCont() for vector<bool>. +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 427 of file mem_stream.h. +
+
00427 {IStream::serialCont(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::CMemStream::serialCont ( std::list< T > & cont ) [inline]
+
+ + + + + +
+ + + +
+Specialisation of serialCont() for vector<bool>. +
+ +
+Reimplemented from NLMISC::IStream. +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 425 of file mem_stream.h. +
+
00425 {IStream::serialCont(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::CMemStream::serialCont ( std::vector< T > & cont ) [inline]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLMISC::CBitMemStream, and NLMISC::CStringStream. +
+Definition at line 423 of file mem_stream.h. +
+Referenced by NLNET::cbInfo(), NLNET::cbPacsAnswer(), NLNET::cbRegisterBroadcast(), NLNET::cleanRequest(), NLNET::CNamingClient::registerService(), NLNET::CNamingClient::registerServiceWithSId(), and NLNET::CNamingClient::resendRegisteration(). +
+
00423 {IStream::serialCont(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPolyPtr ( std::multiset< T > & cont ) [inline, inherited]
+
+ + + + + +
+ + + +
+Serialize a check value. An object can stream a check value to check integrity or format of filed or streamed data. Just call serial check with a const value. Write will serial the value. Read will check the value is the same. If it is not, it will throw EInvalidDataStream exception.
+NB: The type of the value must implement an operator == and must be serializable.
Parameters:
+ + +
value the value used to the check.
+
+
See also:
EInvalidDataStream
+ +
+Definition at line 379 of file stream.h. +
+References NLMISC::IStream::serialSTLContPolyPtr(). +
+
00379 {serialSTLContPolyPtr(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPolyPtr ( std::set< T > & cont ) [inline, inherited]
+
+ + + + + +
+ + + +
+Serialize a check value. An object can stream a check value to check integrity or format of filed or streamed data. Just call serial check with a const value. Write will serial the value. Read will check the value is the same. If it is not, it will throw EInvalidDataStream exception.
+NB: The type of the value must implement an operator == and must be serializable.
Parameters:
+ + +
value the value used to the check.
+
+
See also:
EInvalidDataStream
+ +
+Definition at line 377 of file stream.h. +
+References NLMISC::IStream::serialSTLContPolyPtr(). +
+
00377 {serialSTLContPolyPtr(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPolyPtr ( std::deque< T > & cont ) [inline, inherited]
+
+ + + + + +
+ + + +
+Serialize a check value. An object can stream a check value to check integrity or format of filed or streamed data. Just call serial check with a const value. Write will serial the value. Read will check the value is the same. If it is not, it will throw EInvalidDataStream exception.
+NB: The type of the value must implement an operator == and must be serializable.
Parameters:
+ + +
value the value used to the check.
+
+
See also:
EInvalidDataStream
+ +
+Definition at line 375 of file stream.h. +
+References NLMISC::IStream::serialSTLContPolyPtr(). +
+
00375 {serialSTLContPolyPtr(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPolyPtr ( std::list< T > & cont ) [inline, inherited]
+
+ + + + + +
+ + + +
+Serialize a check value. An object can stream a check value to check integrity or format of filed or streamed data. Just call serial check with a const value. Write will serial the value. Read will check the value is the same. If it is not, it will throw EInvalidDataStream exception.
+NB: The type of the value must implement an operator == and must be serializable.
Parameters:
+ + +
value the value used to the check.
+
+
See also:
EInvalidDataStream
+ +
+Definition at line 373 of file stream.h. +
+References NLMISC::IStream::serialSTLContPolyPtr(). +
+
00373 {serialSTLContPolyPtr(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T, class Allocator>
void NLMISC::IStream::serialContPolyPtr ( std::vector< T, Allocator > & cont ) [inline, inherited]
+
+ + + + + +
+ + + +
+Serialize a check value. An object can stream a check value to check integrity or format of filed or streamed data. Just call serial check with a const value. Write will serial the value. Read will check the value is the same. If it is not, it will throw EInvalidDataStream exception.
+NB: The type of the value must implement an operator == and must be serializable.
Parameters:
+ + +
value the value used to the check.
+
+
See also:
EInvalidDataStream
+ +
+Definition at line 371 of file stream.h. +
+References NLMISC::IStream::serialVectorPolyPtr(). +
+Referenced by NL3D::CAnimation::serial(). +
+
00371 {serialVectorPolyPtr(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPtr ( std::multiset< T > & cont ) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 362 of file stream.h. +
+References NLMISC::IStream::serialSTLContPtr(). +
+
00362 {serialSTLContPtr(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPtr ( std::set< T > & cont ) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 360 of file stream.h. +
+References NLMISC::IStream::serialSTLContPtr(). +
+
00360 {serialSTLContPtr(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPtr ( std::deque< T > & cont ) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 358 of file stream.h. +
+References NLMISC::IStream::serialSTLContPtr(). +
+
00358 {serialSTLContPtr(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPtr ( std::list< T > & cont ) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 356 of file stream.h. +
+References NLMISC::IStream::serialSTLContPtr(). +
+
00356 {serialSTLContPtr(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T, class Allocator>
void NLMISC::IStream::serialContPtr ( std::vector< T, Allocator > & cont ) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 354 of file stream.h. +
+References NLMISC::IStream::serialVectorPtr(). +
+Referenced by NL3D::CAnimationSet::serial(). +
+
00354 {serialVectorPtr(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialEnum ( T & em ) [inline, inherited]
+
+ + + + + +
+ + + +
+Template enum serialisation. Serialized as a sint32. +
+ +
+Definition at line 261 of file stream.h. +
+References NLMISC::IStream::isReading(), NLMISC::IStream::serial(), and sint32. +
+Referenced by NLNET::cbTCReceiveOtherSideClass(), NL3D::CVegetableShape::serial(), NL3D::CVegetable::serial(), NLPACS::CRetrieverInstance::serial(), NL3D::CPointLight::serial(), NL3D::CMaterial::serial(), NLPACS::CLocalRetriever::serial(), NLMISC::CSerialCommand::serial(), and NL3D::CAnimationPlaylist::serial(). +
+
00262 { +00263 sint32 i; +00264 if(isReading()) +00265 { +00266 serial(i); +00267 em = (T)i; +00268 } +00269 else +00270 { +00271 i = em; +00272 serial(i); +00273 } +00274 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::serialHex ( uint32 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+Serialisation in hexadecimal. +
+ +
+Reimplemented in NLMISC::CStringStream. +
+Definition at line 929 of file mem_stream.h. +
+References _StringMode, NLMISC::atoihex(), NLMISC::IStream::isReading(), readnumber, uint32, and writenumber. +
+Referenced by NLNET::TMessageRecord::serial(). +
+
00930 { +00931 if ( _StringMode ) +00932 { +00933 if ( isReading() ) +00934 { +00935 readnumber( b, uint32, 10, atoihex ); // 4294967295 +00936 } +00937 else +00938 { +00939 writenumber( b, "%x", 10 ); +00940 } +00941 } +00942 else +00943 { +00944 IStream::serial( b ); +00945 } +00946 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serialMemStream ( CMemStream & b ) [virtual, inherited]
+
+ + + + + +
+ + + +
+Serial memstream, bitmemstream... +
+ +
+Definition at line 436 of file stream.cpp. +
+References buffer(), bufferToFill(), NLMISC::IStream::isReading(), len, length(), resetBufPos(), NLMISC::IStream::serial(), NLMISC::IStream::serialBuffer(), uint32, and uint8. +
+
00437 { +00438 uint32 len=0; +00439 +00440 // Serialize length +00441 if ( isReading() ) +00442 { +00443 // fill b with data from this +00444 serial (len); +00445 serialBuffer (b.bufferToFill (len), len); +00446 b.resetBufPos (); +00447 } +00448 else +00449 { +00450 // fill this with data from b +00451 len = b.length(); +00452 +00453 serial( len ); +00454 serialBuffer( (uint8*) b.buffer (), len ); +00455 } +00456 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialPolyPtr ( T *& ptr ) [inline, inherited]
+
+ + + + + +
+ + + +
+Serialize Polymorphic Objet Ptr. Works with NULL pointers. If the same object is found mutliple time in the stream, ONLY ONE instance is written! NB: The ptr is serialised as a uint64 (64 bit compliant).
Parameters:
+ + +
ptr a pointer on a IStreamable object.
+
+
See also:
resetPtrTable()
+ +
+Definition at line 492 of file stream.h. +
+References NLMISC::IStream::serialIStreamable(). +
+Referenced by NL3D::CAnimationOptimizer::cloneTrack(), NL3D::CMaterial::CLightMap::serial(), NL3D::CMaterial::serial(), NL3D::CMaterialBase::CAnimatedTexture::serial(), NL3D::CMaterial::CLightMap::serial2(), and NLMISC::IStream::serialSTLContLenPolyPtr(). +
+
00493 { IStreamable *p=ptr; serialIStreamable(p); ptr= static_cast<T*>(p);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialPtr ( T *& ptr ) [inline, inherited]
+
+ + + + + +
+ + + +
+Serialize Non Polymorphic Objet Ptr. Works with NULL pointers. If the same object is found mutliple time in the stream, ONLY ONE instance is written! NB: The ptr is serialised as a uint64 (64 bit compliant).
Parameters:
+ + +
ptr a pointer on a base type or an object.
+
+
See also:
resetPtrTable()
+ +
+Definition at line 390 of file stream.h. +
+References NLMISC::IStream::_IdMap, NLMISC::IStream::_NextSerialPtrId, NLMISC::IStream::isReading(), NLMISC::IStream::ItIdMap, NLMISC::IStream::serial(), uint, uint64, NLMISC::IStream::ValueIdMap, NLMISC::IStream::xmlPop(), NLMISC::IStream::xmlPushBegin(), NLMISC::IStream::xmlPushEnd(), and NLMISC::IStream::xmlSetAttrib(). +
+Referenced by NL3D::CParticleSystemShape::buildFromPS(), NL3D::CParticleSystemShape::flushTextures(), NL3D::CParticleSystemShape::instanciatePS(), and NLMISC::IStream::serialSTLContLenPtr(). +
+
00391 { +00392 uint64 node; +00393 +00394 // Open the node header +00395 xmlPushBegin ("PTR"); +00396 +00397 xmlSetAttrib ("id"); +00398 +00399 if(isReading()) +00400 { +00401 serial(node); +00402 +00403 // Close the header +00404 xmlPushEnd (); +00405 +00406 if(node==0) +00407 ptr=NULL; +00408 else +00409 { +00410 ItIdMap it; +00411 it= _IdMap.find(node); +00412 +00413 // Test if object already created/read. +00414 if( it==_IdMap.end() ) +00415 { +00416 // Construct object. +00417 ptr= new T; +00418 if(ptr==NULL) +00419 throw EStream(); +00420 +00421 // Insert the node. +00422 _IdMap.insert( ValueIdMap(node, ptr) ); +00423 +00424 // Read the object! +00425 serial(*ptr); +00426 } +00427 else +00428 ptr= static_cast<T*>(it->second); +00429 } +00430 } +00431 else +00432 { +00433 if(ptr==NULL) +00434 { +00435 node= 0; +00436 serial(node); +00437 +00438 // Close the header +00439 xmlPushEnd (); +00440 } +00441 else +00442 { +00443 ItIdMap it; +00444 it = _IdMap.find((uint64)(uint)ptr); +00445 +00446 // Test if object has been already written +00447 if( it==_IdMap.end() ) +00448 { +00449 // Not yet written +00450 +00451 // Get the next available ID +00452 node = _NextSerialPtrId++; +00453 +00454 // Serial the id +00455 serial(node); +00456 +00457 // Insert the pointer in the map with the id +00458 _IdMap.insert( ValueIdMap((uint64)(uint)ptr, (void*)(uint)node) ); +00459 +00460 // Close the header +00461 xmlPushEnd (); +00462 +00463 // Write the object +00464 serial(*ptr); +00465 } +00466 else +00467 { +00468 // Write only the object id +00469 node = (uint64)(uint)(it->second); +00470 +00471 serial(node); +00472 +00473 // Close the header +00474 xmlPushEnd (); +00475 } +00476 } +00477 } +00478 +00479 // Close the node +00480 xmlPop (); +00481 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
uint NLMISC::CMemStream::serialSeparatedBufferIn ( uint8 * buf,
uint len
)
+
+ + + + + +
+ + + +
+Input: read len bytes at most from the stream until the next separator, and return the number of bytes read. The separator is then skipped. +
+ +
+Reimplemented in NLMISC::CStringStream. +
+Definition at line 307 of file mem_stream.cpp. +
+References _BufPos, _StringMode, NLMISC::CObjectVector< uint8, false >::getPtr(), NLMISC::IStream::isReading(), len, length(), lengthS(), nlassert, NLMISC::SEP_SIZE, NLMISC::SEPARATOR, NLMISC::CObjectVector< uint8, false >::size(), uint, uint32, and uint8. +
+
00308 { +00309 nlassert( _StringMode && isReading() ); +00310 +00311 // Check that we don't read more than there is to read +00312 if ( ( _BufPos == _Buffer.getPtr()+_Buffer.size() ) || // we are at the end +00313 ( lengthS()+len+SEP_SIZE > length() ) && (_Buffer[_Buffer.size()-1] != SEPARATOR ) ) // we are before the end // calls virtual length (cf. sub messages) +00314 { +00315 throw EStreamOverflow(); +00316 } +00317 // Serialize in +00318 uint32 i = 0; +00319 while ( (i<len) && (*_BufPos) != SEPARATOR ) +00320 { +00321 *(buf+i) = *_BufPos; +00322 i++; +00323 _BufPos++; +00324 } +00325 // Exceeds len +00326 if ( (*_BufPos) != SEPARATOR ) +00327 { +00328 throw EStreamOverflow(); +00329 } +00330 _BufPos += SEP_SIZE; +00331 return i; +00332 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::CMemStream::serialSeparatedBufferOut ( uint8 * buf,
uint len
)
+
+ + + + + +
+ + + +
+Output: writes len bytes from buf into the stream. +
+ +
+Reimplemented in NLMISC::CStringStream. +
+Definition at line 338 of file mem_stream.cpp. +
+References _BufPos, _StringMode, NLMISC::CObjectVector< uint8, false >::getPtr(), NLMISC::IStream::isReading(), len, nlassert, NLMISC::CObjectVector< uint8, false >::resize(), NLMISC::SEP_SIZE, NLMISC::SEPARATOR, NLMISC::CObjectVector< uint8, false >::size(), uint, uint32, and uint8. +
+
00339 { +00340 nlassert( _StringMode && (!isReading()) ); +00341 +00342 // Serialize out +00343 uint32 oldBufferSize = _Buffer.size(); +00344 if (_BufPos - _Buffer.getPtr() + (len + SEP_SIZE) > oldBufferSize) +00345 { +00346 // need to increase the buffer size +00347 _Buffer.resize(oldBufferSize*2 + len + SEP_SIZE); +00348 _BufPos = _Buffer.getPtr() + oldBufferSize; +00349 } +00350 +00351 CFastMem::memcpy( _BufPos, buf, len ); +00352 _BufPos += len; +00353 *(_BufPos++) = SEPARATOR; +00354 +00355 // Serialize out +00356 /* _Buffer.resize( _Buffer.size() + len + SEP_SIZE ); +00357 _BufPos = _Buffer.end() - len - SEP_SIZE; +00358 CFastMem::memcpy( &(*_BufPos), buf, len ); +00359 _Buffer[_Buffer.size()-1] = SEPARATOR; +00360 _BufPos = _Buffer.end(); +00361 */} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialVector ( T & cont ) [inline, protected, inherited]
+
+ + + + + +
+ + + +
+special version for serializing a vector. Support up to sint32 length containers. +
+Definition at line 992 of file stream.h. +
+References NLMISC::contReset(), NLMISC::IStream::isReading(), len, NLMISC::IStream::serial(), sint, sint32, NLMISC::IStream::xmlPop(), NLMISC::IStream::xmlPush(), NLMISC::IStream::xmlPushBegin(), NLMISC::IStream::xmlPushEnd(), and NLMISC::IStream::xmlSetAttrib(). +
+Referenced by NLMISC::CStringStream::serialCont(), NLMISC::IStream::serialCont(), and NLMISC::CBitMemStream::serialCont(). +
+
00993 { +00994 typedef typename T::value_type __value_type; +00995 typedef typename T::iterator __iterator; +00996 +00997 // Open a node header +00998 xmlPushBegin ("VECTOR"); +00999 +01000 // Attrib size +01001 xmlSetAttrib ("size"); +01002 +01003 sint32 len=0; +01004 if(isReading()) +01005 { +01006 serial(len); +01007 +01008 // Open a node header +01009 xmlPushEnd (); +01010 +01011 // special version for vector: adjut good size. +01012 contReset(cont); +01013 cont.resize (len); +01014 +01015 // Read the vector +01016 for(sint i=0;i<len;i++) +01017 { +01018 xmlPush ("ELM"); +01019 +01020 serial(cont[i]); +01021 +01022 xmlPop (); +01023 } +01024 } +01025 else +01026 { +01027 len= cont.size(); +01028 serial(len); +01029 +01030 // Close the node header +01031 xmlPushEnd (); +01032 +01033 // Write the vector +01034 __iterator it= cont.begin(); +01035 for(sint i=0;i<len;i++, it++) +01036 { +01037 xmlPush ("ELM"); +01038 +01039 serial(const_cast<__value_type&>(*it)); +01040 +01041 xmlPop (); +01042 } +01043 } +01044 +01045 // Close the node +01046 xmlPop (); +01047 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::setInOut ( bool inputStream ) [protected, inherited]
+
+ + + + + +
+ + + +
+Change, in live, the state of the inputStream. This could be usefull in certain case. The deriver which would want to do such a thing must call this method, and implement his own behavior. In certain case, it should call resetPtrTable() if he want to reset the stream ptr info (maybe always)... +
+Definition at line 413 of file stream.cpp. +
+References NLMISC::IStream::_InputStream. +
+Referenced by NLMISC::CBitMemStream::getSerialItem(), and invert(). +
+
00414 { +00415 _InputStream= inputStream; +00416 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::setStringMode ( bool stringmode ) [inline]
+
+ + + + + +
+ + + +
+Set string mode. +
+ +
+Definition at line 113 of file mem_stream.h. +
+References _StringMode. +
+Referenced by NLNET::CMessage::init(). +
+
00113 { _StringMode = stringmode; } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::IStream::setVersionException ( bool throwOnOlder,
bool throwOnNewer
) [static, inherited]
+
+ + + + + +
+ + + +
+Set the behavior of IStream regarding input stream that are older/newer than the class. If throwOnOlder==true, IStream throws a EOlderStream when needed. If throwOnNewer==true, IStream throws a ENewerStream when needed.
+By default, the behavior is throwOnOlder=false, throwOnNewer=true.
See also:
serialVersion() getVersionException()
+ +
+Definition at line 71 of file stream.cpp. +
+References NLMISC::IStream::_ThrowOnNewer, and NLMISC::IStream::_ThrowOnOlder. +
+
00072 { +00073 _ThrowOnOlder=throwOnOlder; +00074 _ThrowOnNewer=throwOnNewer; +00075 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::setXMLMode ( bool on ) [protected, inherited]
+
+ + + + + +
+ + + +
+Set the XML mode is true to enable XML mode else false +
+Definition at line 427 of file stream.cpp. +
+References NLMISC::IStream::_XML. +
+Referenced by NLMISC::COXml::COXml(), and NLMISC::COXml::init(). +
+
00428 { +00429 _XML = on; +00430 } +

+

+ + + + +
+ + + + + + + + + +
uint32 NLMISC::CMemStream::size ( ) const [inline]
+
+ + + + + +
+ + + +
+Returns the size of the buffer (can be greater than the length, especially in output mode). +
+ +
+Definition at line 230 of file mem_stream.h. +
+References NLMISC::CObjectVector< uint8, false >::size(), and uint32. +
+Referenced by lengthR(). +
+
00231 { +00232 return _Buffer.size(); +00233 } +

+

+ + + + +
+ + + + + + + + + +
bool NLMISC::CMemStream::stringMode ( ) const [inline]
+
+ + + + + +
+ + + +
+Return string mode. +
+ +
+Definition at line 116 of file mem_stream.h. +
+References _StringMode. +
+Referenced by NLNET::TMessageRecord::serial(), and NLNET::CInetAddress::serial(). +
+
00116 { return _StringMode; } +

+

+ + + + +
+ + + + + + + + + +
bool NLMISC::IStream::xmlBreakLine ( ) [inline, inherited]
+
+ + + + + +
+ + + +
+xmlBreakLine() insert a break line in the XML stream.
+
Returns:
true if the break line is added, return false if no node is opened.
+ +
+Definition at line 794 of file stream.h. +
+References NLMISC::IStream::_XML, and NLMISC::IStream::xmlBreakLineInternal(). +
+
00795 { +00796 // XML Mode ? +00797 if (_XML) +00798 { +00799 return xmlBreakLineInternal (); +00800 } +00801 +00802 // Return ok +00803 return true; +00804 } +

+

+ + + + +
+ + + + + + + + + +
virtual bool NLMISC::IStream::xmlBreakLineInternal ( ) [inline, protected, virtual, inherited]
+
+ + + + + +
+ + + +
+xmlBreakLine implementation +
+ +
+Reimplemented in NLMISC::COXml. +
+Definition at line 845 of file stream.h. +
+Referenced by NLMISC::IStream::xmlBreakLine(). +
+
00845 { return true; }; +

+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::IStream::xmlComment ( const char * comment ) [inline, inherited]
+
+ + + + + +
+ + + +
+xmlComment() insert a comment line in the XML stream.
+
Returns:
true if the comment is added, return false if no node is opened.
+ +
+Definition at line 811 of file stream.h. +
+References NLMISC::IStream::_XML, comment(), and NLMISC::IStream::xmlCommentInternal(). +
+
00812 { +00813 // XML Mode ? +00814 if (_XML) +00815 { +00816 return xmlCommentInternal (comment); +00817 } +00818 +00819 // Return ok +00820 return true; +00821 } +

+

+ + + + +
+ + + + + + + + + + +
virtual bool NLMISC::IStream::xmlCommentInternal ( const char * comment ) [inline, protected, virtual, inherited]
+
+ + + + + +
+ + + +
+xmlComment implementation +
+ +
+Reimplemented in NLMISC::COXml. +
+Definition at line 848 of file stream.h. +
+Referenced by NLMISC::IStream::xmlComment(). +
+
00848 { return true; }; +

+

+ + + + +
+ + + + + + + + + +
virtual bool NLMISC::IStream::xmlPopInternal ( ) [inline, protected, virtual, inherited]
+
+ + + + + +
+ + + +
+xmlPop implementation +
+ +
+Reimplemented in NLMISC::COXml. +
+Definition at line 839 of file stream.h. +
+Referenced by NLMISC::IStream::xmlPop(). +
+
00839 { return true; }; +

+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::IStream::xmlPush ( const char * name ) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 701 of file stream.h. +
+References NLMISC::IStream::_XML, res, NLMISC::IStream::xmlPushBeginInternal(), and NLMISC::IStream::xmlPushEndInternal(). +
+Referenced by NLLIGO::CZoneRegion::serial(), NLLIGO::CZoneBankElement::serial(), NL3D::CZone::serial(), NL3D::CPatch::serial(), NLMISC::CObjectVector< sint8, false >::serial(), NLMISC::COXml::serial(), NLMISC::COXml::serialBuffer(), NLMISC::IStream::serialCheck(), NLMISC::IStream::serialMap(), NLMISC::IStream::serialMultimap(), NLMISC::IStream::serialSTLContLen(), NLMISC::IStream::serialVector(), NLMISC::IStream::serialVersion(), and NLMISC::IStream::xmlSerial(). +
+
00702 { +00703 // XML Mode ? +00704 if (_XML) +00705 { +00706 // Open the header +00707 bool res=xmlPushBeginInternal (name); +00708 if (res) +00709 // close the header +00710 xmlPushEndInternal (); +00711 // Return the result +00712 return res; +00713 } +00714 +00715 // Return ok +00716 return true; +00717 } +

+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::IStream::xmlPushBegin ( const char * name ) [inline, inherited]
+
+ + + + + +
+ + + +
+xmlBreakLine() insert a break line in the XML stream.
+
Returns:
true if the break line is added, return false if no node is opened.
+ +
+Definition at line 725 of file stream.h. +
+References NLMISC::IStream::_XML, and NLMISC::IStream::xmlPushBeginInternal(). +
+Referenced by NLMISC::CObjectVector< sint8, false >::serial(), NLMISC::IStream::serialIStreamable(), NLMISC::IStream::serialMap(), NLMISC::IStream::serialMultimap(), NLMISC::IStream::serialPtr(), NLMISC::IStream::serialSTLCont(), NLMISC::IStream::serialSTLContPtr(), NLMISC::IStream::serialVector(), NLMISC::IStream::serialVectorPolyPtr(), and NLMISC::IStream::serialVectorPtr(). +
+
00726 { +00727 // XML Mode ? +00728 if (_XML) +00729 { +00730 return xmlPushBeginInternal (name); +00731 } +00732 +00733 // Return ok +00734 return true; +00735 } +

+

+ + + + +
+ + + + + + + + + + +
virtual bool NLMISC::IStream::xmlPushBeginInternal ( const char * name ) [inline, protected, virtual, inherited]
+
+ + + + + +
+ + + +
+xmlPushBegin implementation +
+ +
+Reimplemented in NLMISC::COXml. +
+Definition at line 833 of file stream.h. +
+Referenced by NLMISC::IStream::xmlPush(), and NLMISC::IStream::xmlPushBegin(). +
+
00833 { return true; }; +

+

+ + + + +
+ + + + + + + + + +
bool NLMISC::IStream::xmlPushEnd ( ) [inline, inherited]
+
+ + + + + +
+ + + +
+xmlPushEnd() close the node header.
+
Returns:
true if you can close the node header, false if no node header have been opened with xmlPushBegin().
+ +
+Definition at line 742 of file stream.h. +
+References NLMISC::IStream::_XML, and NLMISC::IStream::xmlPushEndInternal(). +
+Referenced by NLMISC::CObjectVector< sint8, false >::serial(), NLMISC::IStream::serialIStreamable(), NLMISC::IStream::serialMap(), NLMISC::IStream::serialMultimap(), NLMISC::IStream::serialPtr(), NLMISC::IStream::serialSTLCont(), NLMISC::IStream::serialSTLContPtr(), NLMISC::IStream::serialVector(), NLMISC::IStream::serialVectorPolyPtr(), and NLMISC::IStream::serialVectorPtr(). +
+
00743 { +00744 // XML Mode ? +00745 if (_XML) +00746 { +00747 return xmlPushEndInternal (); +00748 } +00749 +00750 // Return ok +00751 return true; +00752 } +

+

+ + + + +
+ + + + + + + + + +
virtual bool NLMISC::IStream::xmlPushEndInternal ( ) [inline, protected, virtual, inherited]
+
+ + + + + +
+ + + +
+xmlPushEnd implementation +
+ +
+Reimplemented in NLMISC::COXml. +
+Definition at line 836 of file stream.h. +
+Referenced by NLMISC::IStream::xmlPush(), and NLMISC::IStream::xmlPushEnd(). +
+
00836 { return true; }; +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::xmlSerial ( T & value0,
T & value1,
T & value2,
T & value3,
const char * nodeName
) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 683 of file stream.h. +
+References NLMISC::IStream::serial(), NLMISC::IStream::xmlPop(), and NLMISC::IStream::xmlPush(). +
+
00684 { +00685 // Open the node +00686 xmlPush (nodeName); +00687 +00688 // Serial the values +00689 serial (value0, value1, value2, value3); +00690 +00691 // Close the node +00692 xmlPop (); +00693 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::xmlSerial ( T & value0,
T & value1,
T & value2,
const char * nodeName
) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 671 of file stream.h. +
+References NLMISC::IStream::serial(), NLMISC::IStream::xmlPop(), and NLMISC::IStream::xmlPush(). +
+
00672 { +00673 // Open the node +00674 xmlPush (nodeName); +00675 +00676 // Serial the values +00677 serial (value0, value1, value2); +00678 +00679 // Close the node +00680 xmlPop (); +00681 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::xmlSerial ( T & value0,
T & value1,
const char * nodeName
) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 659 of file stream.h. +
+References NLMISC::IStream::serial(), NLMISC::IStream::xmlPop(), and NLMISC::IStream::xmlPush(). +
+
00660 { +00661 // Open the node +00662 xmlPush (nodeName); +00663 +00664 // Serial the values +00665 serial (value0, value1); +00666 +00667 // Close the node +00668 xmlPop (); +00669 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::xmlSerial ( T & value0,
const char * nodeName
) [inline, inherited]
+
+ + + + + +
+ + + +
+xmlSerial() serial a values into a node. +
+Definition at line 647 of file stream.h. +
+References NLMISC::IStream::serial(), NLMISC::IStream::xmlPop(), and NLMISC::IStream::xmlPush(). +
+Referenced by NLLIGO::CZoneRegion::serial(), NLLIGO::CZoneRegion::SZoneUnit2::serial(), NLLIGO::CZoneRegion::SZoneUnit::serial(), NL3D::CZone::serial(), NL3D::CPatchInfo::CBindInfo::serial(), NL3D::CZone::CPatchConnect::serial(), NL3D::CBorderVertex::serial(), NL3D::CTileElement::serial(), NL3D::CTileColorOldPatchVersion6::serial(), NL3D::CTileColor::serial(), and NL3D::CPatch::serial(). +
+
00648 { +00649 // Open the node +00650 xmlPush (nodeName); +00651 +00652 // Serial the value +00653 serial (value0); +00654 +00655 // Close the node +00656 xmlPop (); +00657 } +

+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::IStream::xmlSetAttrib ( const char * name ) [inline, inherited]
+
+ + + + + +
+ + + +
+xmlSetAttrib() set the name of the next node header attribute serialised.
+is the name of the node header attribute serialised.
Returns:
true if the attribute name have been set, false if the node header is not open (the call is not between xmlPushBegin and xmlPushEnd)
+ +
+Definition at line 777 of file stream.h. +
+References NLMISC::IStream::_XML, and NLMISC::IStream::xmlSetAttribInternal(). +
+Referenced by NLMISC::CObjectVector< sint8, false >::serial(), NLMISC::IStream::serialIStreamable(), NLMISC::IStream::serialMap(), NLMISC::IStream::serialMultimap(), NLMISC::IStream::serialPtr(), NLMISC::IStream::serialSTLCont(), NLMISC::IStream::serialSTLContPtr(), NLMISC::IStream::serialVector(), NLMISC::IStream::serialVectorPolyPtr(), and NLMISC::IStream::serialVectorPtr(). +
+
00778 { +00779 // XML Mode ? +00780 if (_XML) +00781 { +00782 return xmlSetAttribInternal (name); +00783 } +00784 +00785 // Return ok +00786 return true; +00787 } +

+

+ + + + +
+ + + + + + + + + + +
virtual bool NLMISC::IStream::xmlSetAttribInternal ( const char * name ) [inline, protected, virtual, inherited]
+
+ + + + + +
+ + + +
+xmlBreakLine implementation +
+ +
+Reimplemented in NLMISC::COXml. +
+Definition at line 842 of file stream.h. +
+Referenced by NLMISC::IStream::xmlSetAttrib(). +
+
00842 { return true; }; +

+

Field Documentation

+ + + + +
+ + +
CObjectVector<uint8, false> NLMISC::CMemStream::_Buffer [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 516 of file mem_stream.h. +
+Referenced by operator=().
+

+ + + + +
+ + +
uint8* NLMISC::CMemStream::_BufPos [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 517 of file mem_stream.h. +
+Referenced by bufferToFill(), clear(), CMemStream(), fastRead(), fastSerial(), fastWrite(), fill(), getPos(), increaseBufferIfNecessary(), invert(), lengthS(), operator=(), poke(), reserve(), resetBufPos(), resize(), serialBuffer(), serialSeparatedBufferIn(), and serialSeparatedBufferOut().
+

+ + + + +
+ + +
uint32 NLMISC::CMemStream::_DefaultCapacity [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 521 of file mem_stream.h. +
+Referenced by clear(), CMemStream(), and operator=().
+

+ + + + +
+ + +
bool NLMISC::CMemStream::_StringMode [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 519 of file mem_stream.h. +
+Referenced by CMemStream(), operator=(), serial(), serialHex(), serialSeparatedBufferIn(), serialSeparatedBufferOut(), setStringMode(), and stringMode().
+

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

Generated on Tue Mar 16 13:23:07 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1


Seek fonctionnality
enum	TSeekOrigin { begin, +current, +end + }
virtual std::string	getStreamName () const
Public Types
Public Member Functions
const uint8 *	buffer () const
uint8 *	bufferToFill (uint32 msgsize)
virtual void	clear ()
	Clears the message.
	CMemStream (const CMemStream &other)
	Copy constructor.
	CMemStream (bool inputStream=false, bool stringmode=false, uint32 defaultcapacity=0)
	Initialization constructor.
template<class T> void	fastRead (T &value)
template<class T> void	fastSerial (T &val)
template<class T> void	fastWrite (const T &value)
void	fill (const uint8 *srcbuf, uint32 len)
sint32	getPos () const
	Const and not-virtual getPos(), for direct use. Caution: should not be overloaded in a child class.
virtual sint32	getPos () throw (EStream)
void	increaseBufferIfNecessary (uint32 len)
	Increase the buffer size if 'len' can't enter, otherwise, do nothing.
virtual void	invert ()
bool	isReading () const
	Is this stream a Read/Input stream?
bool	isXML () const
virtual uint32	length () const
CMemStream &	operator= (const CMemStream &other)
	Assignment operator.
template<class T> void	poke (T value, sint32 pos)
sint32	reserve (uint len)
void	resetBufPos ()
void	resetPtrTable ()
	Force to reset the ptr table.
void	resize (uint32 size)
	Resize the buffer.
virtual bool	seek (sint32 offset, TSeekOrigin origin) throw (EStream)
template<class T0, class T1, class T2, class T3, class T4, class T5> void	serial (T0 &a, T1 &b, T2 &c, T3 &d, T4 &e, T5 &f)
template<class T0, class T1, class T2, class T3, class T4> void	serial (T0 &a, T1 &b, T2 &c, T3 &d, T4 &e)
template<class T0, class T1, class T2, class T3> void	serial (T0 &a, T1 &b, T2 &c, T3 &d)
template<class T0, class T1, class T2> void	serial (T0 &a, T1 &b, T2 &c)
template<class T0, class T1> void	serial (T0 &a, T1 &b)
template<class T> void	serial (T &obj)
	Template serialisation (should take the one from IStream).
virtual void	serialBit (bool &bit)
	Method inherited from IStream.
virtual void	serialBuffer (uint8 *buf, uint len)
	Method inherited from IStream.
virtual void	serialBufferWithSize (uint8 *buf, uint32 len)
virtual void	serialCont (std::vector< bool > &cont)
	Specialisation of serialCont() for vector<bool>.
virtual void	serialCont (std::vector< sint8 > &cont)
	Specialisation of serialCont() for vector<sint8>.
virtual void	serialCont (std::vector< uint8 > &cont)
	Specialisation of serialCont() for vector<uint8>.
template<class K, class T> void	serialCont (std::multimap< K, T > &cont)
	Specialisation of serialCont() for vector<bool>.
template<class K, class T> void	serialCont (std::map< K, T > &cont)
	Specialisation of serialCont() for vector<bool>.
template<class T> void	serialCont (std::multiset< T > &cont)
	Specialisation of serialCont() for vector<bool>.
template<class T> void	serialCont (std::set< T > &cont)
	Specialisation of serialCont() for vector<bool>.
template<class T> void	serialCont (std::deque< T > &cont)
	Specialisation of serialCont() for vector<bool>.
template<class T> void	serialCont (std::list< T > &cont)
	Specialisation of serialCont() for vector<bool>.
template<class T> void	serialCont (std::vector< T > &cont)
template<class T> void	serialEnum (T &em)
	Template enum serialisation. Serialized as a sint32.
virtual void	serialMemStream (CMemStream &b)
	Serial memstream, bitmemstream...
void	setStringMode (bool stringmode)
	Set string mode.
uint32	size () const
	Returns the size of the buffer (can be greater than the length, especially in output mode).
bool	stringMode () const
	Return string mode.
Static Public Member Functions
void	getVersionException (bool &throwOnOlder, bool &throwOnNewer)
void	setVersionException (bool throwOnOlder, bool throwOnNewer)
Protected Member Functions
uint32	lengthR () const
uint32	lengthS () const
	Returns the serialized length (number of bytes written or read).
template<class T> void	serialVector (T &cont)
Protected Attributes
CObjectVector< uint8, false >	_Buffer
uint8 *	_BufPos
uint32	_DefaultCapacity
bool	_StringMode