NLMISC::CStringStream Class Reference

#include <string_stream.h>

Inheritance diagram for NLMISC::CStringStream:

---

Detailed Description

Memory stream that is serialized from/to plain text (human-readable). not any comparaison with the stl class std::stringstream

Author:

Olivier Cado

Nevrax France

Date:

2001

Definition at line 43 of file string_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.
	CStringStream (const CStringStream &other)
	Copy constructor.
	CStringStream (bool inputStream=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
CStringStream &	operator= (const CStringStream &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	serialHex (uint32 &b)
	Serialisation in hexadecimal.
virtual void	serialMemStream (CMemStream &b)
	Serial memstream, bitmemstream...
uint	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.
void	serialSeparatedBufferOut (uint8 *buf, uint len)
	Output: writes len bytes from buf into the stream.
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.
BitField serialisation.
Unlike other serial method, The reading bitfield is returned!! If !this->isReading(), bf is returned. MUST use it simply like this: a= serialBitFieldX(a); // where X== 8, 16 or 32. NB: Performance warning: the data is stored as an uint8, uint16 or uint32, according to the method you use.
uint16	serialBitField16 (uint16 bf)
	Serialisation of bitfield <=16 bits.
uint32	serialBitField32 (uint32 bf)
	Serialisation of bitfield <=32 bits.
uint8	serialBitField8 (uint8 bf)
	Serialisation of bitfield <=8 bits.
standard STL containers serialisation. Elements must be pointers on a IStreamable object.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPtr()
template<class T> void	serialCheck (const T &value)
template<class T> void	serialContPolyPtr (std::multiset< T > &cont)
template<class T> void	serialContPolyPtr (std::set< T > &cont)
template<class T> void	serialContPolyPtr (std::deque< T > &cont)
template<class T> void	serialContPolyPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPolyPtr (std::vector< T, Allocator > &cont)
template<class T> void	serialPolyPtr (T *&ptr)
template<class T> void	serialPtr (T *&ptr)
uint	serialVersion (uint currentVersion)
standard STL containers serialisation.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<>, map<>, multimap<> Support up to sint32 length containers. See also: serialContPtr() serialContPolyPtr()
template<class T, class Allocator> void	serialCont (std::vector< T, Allocator > &cont)
	Specialisation of serialCont() for vector<bool>.
standard STL containers serialisation. Elements must be pointers on a base type (uint...) or on a
object providing "void serial(IStream&)" method. Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPolyPtr()
template<class T> void	serialContPtr (std::multiset< T > &cont)
template<class T> void	serialContPtr (std::set< T > &cont)
template<class T> void	serialContPtr (std::deque< T > &cont)
template<class T> void	serialContPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPtr (std::vector< T, Allocator > &cont)
is the name of the node to open
xmlPushBegin() open recurcively a new node and open its header. You must call xmlPushEnd() to close the header and xmlPop() to close this node. Returns: true if you can open the node header, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlBreakLine ()
bool	xmlComment (const char *comment)
bool	xmlPop ()
bool	xmlPushBegin (const char *name)
bool	xmlPushEnd ()
bool	xmlSetAttrib (const char *name)
is the name of the node to open
xmlPush() open recurcively a new node. You must call xmlPop to close this node. Returns: true if you can open the node, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlPush (const char *name)
XML user interface
Those functions are used to add information in your stream to structure it like a XML document. Exemple of a serial sequence : // Start the opening of a new node named Identity stream.xmlPush ("Identity") // Serial some infos stream.serial (name); stream.serial (pseudo); // Open a new node header named Address stream.xmlPushBegin ("Address"); // Set a property name stream.xmlSetAttrib ("Street") // Serial the property stream.serial ("Street"); // Close the new node header stream.xmlPushEnd (); // Serial in this node stream.serial (cityName); // Close the address node stream.xmlPop (); // Add a comment stream.xmlComment ("Hello"); // Close the identity node stream.xmlPop (); The result will be an xml document structured like this: <Identity> Corvazier Hulud <Address Street="rue du Faubourg Saint Antoine"> Paris <\Address> <!-- Hello --> <\Identity> Node header serials are the serialisations done between xmlPushBegin() and xmlPushEnd() call. There is some restrictions on them: Node header serials are only available for basic types (numbers and strings). xmlSetAttrib() must be called before node header serial. Note that XML documents only have ONE root node, so all serialisation must be done between a xmlPush() and a xmlPop() call. When a xml input stream will try to open a node, it will scan all currrent child nodes to find the good one. So input xml stream can skip unknown node.
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, T &value3, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, const char *nodeName)
template<class T> void	xmlSerial (T &value0, const char *nodeName)
BitField serialisation.
Unlike other serial method, The reading bitfield is returned!! If !this->isReading(), bf is returned. MUST use it simply like this: a= serialBitFieldX(a); // where X== 8, 16 or 32. NB: Performance warning: the data is stored as an uint8, uint16 or uint32, according to the method you use.
uint16	serialBitField16 (uint16 bf)
	Serialisation of bitfield <=16 bits.
uint32	serialBitField32 (uint32 bf)
	Serialisation of bitfield <=32 bits.
uint8	serialBitField8 (uint8 bf)
	Serialisation of bitfield <=8 bits.
standard STL containers serialisation. Elements must be pointers on a IStreamable object.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPtr()
template<class T> void	serialCheck (const T &value)
template<class T> void	serialContPolyPtr (std::multiset< T > &cont)
template<class T> void	serialContPolyPtr (std::set< T > &cont)
template<class T> void	serialContPolyPtr (std::deque< T > &cont)
template<class T> void	serialContPolyPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPolyPtr (std::vector< T, Allocator > &cont)
template<class T> void	serialPolyPtr (T *&ptr)
template<class T> void	serialPtr (T *&ptr)
uint	serialVersion (uint currentVersion)
standard STL containers serialisation. Elements must be pointers on a base type (uint...) or on a
object providing "void serial(IStream&)" method. Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPolyPtr()
template<class T> void	serialContPtr (std::multiset< T > &cont)
template<class T> void	serialContPtr (std::set< T > &cont)
template<class T> void	serialContPtr (std::deque< T > &cont)
template<class T> void	serialContPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPtr (std::vector< T, Allocator > &cont)
is the name of the node to open
xmlPushBegin() open recurcively a new node and open its header. You must call xmlPushEnd() to close the header and xmlPop() to close this node. Returns: true if you can open the node header, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlBreakLine ()
bool	xmlComment (const char *comment)
bool	xmlPop ()
bool	xmlPushBegin (const char *name)
bool	xmlPushEnd ()
bool	xmlSetAttrib (const char *name)
is the name of the node to open
xmlPush() open recurcively a new node. You must call xmlPop to close this node. Returns: true if you can open the node, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlPush (const char *name)
XML user interface
Those functions are used to add information in your stream to structure it like a XML document. Exemple of a serial sequence : // Start the opening of a new node named Identity stream.xmlPush ("Identity") // Serial some infos stream.serial (name); stream.serial (pseudo); // Open a new node header named Address stream.xmlPushBegin ("Address"); // Set a property name stream.xmlSetAttrib ("Street") // Serial the property stream.serial ("Street"); // Close the new node header stream.xmlPushEnd (); // Serial in this node stream.serial (cityName); // Close the address node stream.xmlPop (); // Add a comment stream.xmlComment ("Hello"); // Close the identity node stream.xmlPop (); The result will be an xml document structured like this: <Identity> Corvazier Hulud <Address Street="rue du Faubourg Saint Antoine"> Paris <\Address> <!-- Hello --> <\Identity> Node header serials are the serialisations done between xmlPushBegin() and xmlPushEnd() call. There is some restrictions on them: Node header serials are only available for basic types (numbers and strings). xmlSetAttrib() must be called before node header serial. Note that XML documents only have ONE root node, so all serialisation must be done between a xmlPush() and a xmlPop() call. When a xml input stream will try to open a node, it will scan all currrent child nodes to find the good one. So input xml stream can skip unknown node.
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, T &value3, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, const char *nodeName)
template<class T> void	xmlSerial (T &value0, const char *nodeName)
BitField serialisation.
Unlike other serial method, The reading bitfield is returned!! If !this->isReading(), bf is returned. MUST use it simply like this: a= serialBitFieldX(a); // where X== 8, 16 or 32. NB: Performance warning: the data is stored as an uint8, uint16 or uint32, according to the method you use.
uint16	serialBitField16 (uint16 bf)
	Serialisation of bitfield <=16 bits.
uint32	serialBitField32 (uint32 bf)
	Serialisation of bitfield <=32 bits.
uint8	serialBitField8 (uint8 bf)
	Serialisation of bitfield <=8 bits.
standard STL containers serialisation. Elements must be pointers on a IStreamable object.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPtr()
template<class T> void	serialCheck (const T &value)
template<class T> void	serialContPolyPtr (std::multiset< T > &cont)
template<class T> void	serialContPolyPtr (std::set< T > &cont)
template<class T> void	serialContPolyPtr (std::deque< T > &cont)
template<class T> void	serialContPolyPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPolyPtr (std::vector< T, Allocator > &cont)
template<class T> void	serialPolyPtr (T *&ptr)
template<class T> void	serialPtr (T *&ptr)
uint	serialVersion (uint currentVersion)
standard STL containers serialisation.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<>, map<>, multimap<> Support up to sint32 length containers. See also: serialContPtr() serialContPolyPtr()
template<class T, class Allocator> void	serialCont (std::vector< T, Allocator > &cont)
	Specialisation of serialCont() for vector<bool>.
standard STL containers serialisation. Elements must be pointers on a base type (uint...) or on a
object providing "void serial(IStream&)" method. Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPolyPtr()
template<class T> void	serialContPtr (std::multiset< T > &cont)
template<class T> void	serialContPtr (std::set< T > &cont)
template<class T> void	serialContPtr (std::deque< T > &cont)
template<class T> void	serialContPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPtr (std::vector< T, Allocator > &cont)
is the name of the node to open
xmlPushBegin() open recurcively a new node and open its header. You must call xmlPushEnd() to close the header and xmlPop() to close this node. Returns: true if you can open the node header, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlBreakLine ()
bool	xmlComment (const char *comment)
bool	xmlPop ()
bool	xmlPushBegin (const char *name)
bool	xmlPushEnd ()
bool	xmlSetAttrib (const char *name)
is the name of the node to open
xmlPush() open recurcively a new node. You must call xmlPop to close this node. Returns: true if you can open the node, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlPush (const char *name)
XML user interface
Those functions are used to add information in your stream to structure it like a XML document. Exemple of a serial sequence : // Start the opening of a new node named Identity stream.xmlPush ("Identity") // Serial some infos stream.serial (name); stream.serial (pseudo); // Open a new node header named Address stream.xmlPushBegin ("Address"); // Set a property name stream.xmlSetAttrib ("Street") // Serial the property stream.serial ("Street"); // Close the new node header stream.xmlPushEnd (); // Serial in this node stream.serial (cityName); // Close the address node stream.xmlPop (); // Add a comment stream.xmlComment ("Hello"); // Close the identity node stream.xmlPop (); The result will be an xml document structured like this: <Identity> Corvazier Hulud <Address Street="rue du Faubourg Saint Antoine"> Paris <\Address> <!-- Hello --> <\Identity> Node header serials are the serialisations done between xmlPushBegin() and xmlPushEnd() call. There is some restrictions on them: Node header serials are only available for basic types (numbers and strings). xmlSetAttrib() must be called before node header serial. Note that XML documents only have ONE root node, so all serialisation must be done between a xmlPush() and a xmlPop() call. When a xml input stream will try to open a node, it will scan all currrent child nodes to find the good one. So input xml stream can skip unknown node.
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, T &value3, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, const char *nodeName)
template<class T> void	xmlSerial (T &value0, const char *nodeName)
BitField serialisation.
Unlike other serial method, The reading bitfield is returned!! If !this->isReading(), bf is returned. MUST use it simply like this: a= serialBitFieldX(a); // where X== 8, 16 or 32. NB: Performance warning: the data is stored as an uint8, uint16 or uint32, according to the method you use.
uint16	serialBitField16 (uint16 bf)
	Serialisation of bitfield <=16 bits.
uint32	serialBitField32 (uint32 bf)
	Serialisation of bitfield <=32 bits.
uint8	serialBitField8 (uint8 bf)
	Serialisation of bitfield <=8 bits.
standard STL containers serialisation. Elements must be pointers on a IStreamable object.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPtr()
template<class T> void	serialCheck (const T &value)
template<class T> void	serialContPolyPtr (std::multiset< T > &cont)
template<class T> void	serialContPolyPtr (std::set< T > &cont)
template<class T> void	serialContPolyPtr (std::deque< T > &cont)
template<class T> void	serialContPolyPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPolyPtr (std::vector< T, Allocator > &cont)
template<class T> void	serialPolyPtr (T *&ptr)
template<class T> void	serialPtr (T *&ptr)
uint	serialVersion (uint currentVersion)
standard STL containers serialisation.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<>, map<>, multimap<> Support up to sint32 length containers. See also: serialContPtr() serialContPolyPtr()
template<class T, class Allocator> void	serialCont (std::vector< T, Allocator > &cont)
	Specialisation of serialCont() for vector<bool>.
standard STL containers serialisation. Elements must be pointers on a base type (uint...) or on a
object providing "void serial(IStream&)" method. Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPolyPtr()
template<class T> void	serialContPtr (std::multiset< T > &cont)
template<class T> void	serialContPtr (std::set< T > &cont)
template<class T> void	serialContPtr (std::deque< T > &cont)
template<class T> void	serialContPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPtr (std::vector< T, Allocator > &cont)
is the name of the node to open
xmlPushBegin() open recurcively a new node and open its header. You must call xmlPushEnd() to close the header and xmlPop() to close this node. Returns: true if you can open the node header, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlBreakLine ()
bool	xmlComment (const char *comment)
bool	xmlPop ()
bool	xmlPushBegin (const char *name)
bool	xmlPushEnd ()
bool	xmlSetAttrib (const char *name)
is the name of the node to open
xmlPush() open recurcively a new node. You must call xmlPop to close this node. Returns: true if you can open the node, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlPush (const char *name)
XML user interface
Those functions are used to add information in your stream to structure it like a XML document. Exemple of a serial sequence : // Start the opening of a new node named Identity stream.xmlPush ("Identity") // Serial some infos stream.serial (name); stream.serial (pseudo); // Open a new node header named Address stream.xmlPushBegin ("Address"); // Set a property name stream.xmlSetAttrib ("Street") // Serial the property stream.serial ("Street"); // Close the new node header stream.xmlPushEnd (); // Serial in this node stream.serial (cityName); // Close the address node stream.xmlPop (); // Add a comment stream.xmlComment ("Hello"); // Close the identity node stream.xmlPop (); The result will be an xml document structured like this: <Identity> Corvazier Hulud <Address Street="rue du Faubourg Saint Antoine"> Paris <\Address> <!-- Hello --> <\Identity> Node header serials are the serialisations done between xmlPushBegin() and xmlPushEnd() call. There is some restrictions on them: Node header serials are only available for basic types (numbers and strings). xmlSetAttrib() must be called before node header serial. Note that XML documents only have ONE root node, so all serialisation must be done between a xmlPush() and a xmlPop() call. When a xml input stream will try to open a node, it will scan all currrent child nodes to find the good one. So input xml stream can skip unknown node.
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, T &value3, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, const char *nodeName)
template<class T> void	xmlSerial (T &value0, const char *nodeName)
BitField serialisation.
Unlike other serial method, The reading bitfield is returned!! If !this->isReading(), bf is returned. MUST use it simply like this: a= serialBitFieldX(a); // where X== 8, 16 or 32. NB: Performance warning: the data is stored as an uint8, uint16 or uint32, according to the method you use.
uint16	serialBitField16 (uint16 bf)
	Serialisation of bitfield <=16 bits.
uint32	serialBitField32 (uint32 bf)
	Serialisation of bitfield <=32 bits.
uint8	serialBitField8 (uint8 bf)
	Serialisation of bitfield <=8 bits.
standard STL containers serialisation. Elements must be pointers on a IStreamable object.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPtr()
template<class T> void	serialCheck (const T &value)
template<class T> void	serialContPolyPtr (std::multiset< T > &cont)
template<class T> void	serialContPolyPtr (std::set< T > &cont)
template<class T> void	serialContPolyPtr (std::deque< T > &cont)
template<class T> void	serialContPolyPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPolyPtr (std::vector< T, Allocator > &cont)
template<class T> void	serialPolyPtr (T *&ptr)
template<class T> void	serialPtr (T *&ptr)
uint	serialVersion (uint currentVersion)
standard STL containers serialisation. Elements must be pointers on a base type (uint...) or on a
object providing "void serial(IStream&)" method. Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPolyPtr()
template<class T> void	serialContPtr (std::multiset< T > &cont)
template<class T> void	serialContPtr (std::set< T > &cont)
template<class T> void	serialContPtr (std::deque< T > &cont)
template<class T> void	serialContPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPtr (std::vector< T, Allocator > &cont)
is the name of the node to open
xmlPushBegin() open recurcively a new node and open its header. You must call xmlPushEnd() to close the header and xmlPop() to close this node. Returns: true if you can open the node header, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlBreakLine ()
bool	xmlComment (const char *comment)
bool	xmlPop ()
bool	xmlPushBegin (const char *name)
bool	xmlPushEnd ()
bool	xmlSetAttrib (const char *name)
is the name of the node to open
xmlPush() open recurcively a new node. You must call xmlPop to close this node. Returns: true if you can open the node, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlPush (const char *name)
XML user interface
Those functions are used to add information in your stream to structure it like a XML document. Exemple of a serial sequence : // Start the opening of a new node named Identity stream.xmlPush ("Identity") // Serial some infos stream.serial (name); stream.serial (pseudo); // Open a new node header named Address stream.xmlPushBegin ("Address"); // Set a property name stream.xmlSetAttrib ("Street") // Serial the property stream.serial ("Street"); // Close the new node header stream.xmlPushEnd (); // Serial in this node stream.serial (cityName); // Close the address node stream.xmlPop (); // Add a comment stream.xmlComment ("Hello"); // Close the identity node stream.xmlPop (); The result will be an xml document structured like this: <Identity> Corvazier Hulud <Address Street="rue du Faubourg Saint Antoine"> Paris <\Address> <!-- Hello --> <\Identity> Node header serials are the serialisations done between xmlPushBegin() and xmlPushEnd() call. There is some restrictions on them: Node header serials are only available for basic types (numbers and strings). xmlSetAttrib() must be called before node header serial. Note that XML documents only have ONE root node, so all serialisation must be done between a xmlPush() and a xmlPop() call. When a xml input stream will try to open a node, it will scan all currrent child nodes to find the good one. So input xml stream can skip unknown node.
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, T &value3, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, const char *nodeName)
template<class T> void	xmlSerial (T &value0, const char *nodeName)
BitField serialisation.
Unlike other serial method, The reading bitfield is returned!! If !this->isReading(), bf is returned. MUST use it simply like this: a= serialBitFieldX(a); // where X== 8, 16 or 32. NB: Performance warning: the data is stored as an uint8, uint16 or uint32, according to the method you use.
uint16	serialBitField16 (uint16 bf)
	Serialisation of bitfield <=16 bits.
uint32	serialBitField32 (uint32 bf)
	Serialisation of bitfield <=32 bits.
uint8	serialBitField8 (uint8 bf)
	Serialisation of bitfield <=8 bits.
standard STL containers serialisation. Elements must be pointers on a IStreamable object.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPtr()
template<class T> void	serialCheck (const T &value)
template<class T> void	serialContPolyPtr (std::multiset< T > &cont)
template<class T> void	serialContPolyPtr (std::set< T > &cont)
template<class T> void	serialContPolyPtr (std::deque< T > &cont)
template<class T> void	serialContPolyPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPolyPtr (std::vector< T, Allocator > &cont)
template<class T> void	serialPolyPtr (T *&ptr)
template<class T> void	serialPtr (T *&ptr)
uint	serialVersion (uint currentVersion)
standard STL containers serialisation. Elements must be pointers on a base type (uint...) or on a
object providing "void serial(IStream&)" method. Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPolyPtr()
template<class T> void	serialContPtr (std::multiset< T > &cont)
template<class T> void	serialContPtr (std::set< T > &cont)
template<class T> void	serialContPtr (std::deque< T > &cont)
template<class T> void	serialContPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPtr (std::vector< T, Allocator > &cont)
is the name of the node to open
xmlPushBegin() open recurcively a new node and open its header. You must call xmlPushEnd() to close the header and xmlPop() to close this node. Returns: true if you can open the node header, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlBreakLine ()
bool	xmlComment (const char *comment)
bool	xmlPop ()
bool	xmlPushBegin (const char *name)
bool	xmlPushEnd ()
bool	xmlSetAttrib (const char *name)
is the name of the node to open
xmlPush() open recurcively a new node. You must call xmlPop to close this node. Returns: true if you can open the node, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlPush (const char *name)
XML user interface
Those functions are used to add information in your stream to structure it like a XML document. Exemple of a serial sequence : // Start the opening of a new node named Identity stream.xmlPush ("Identity") // Serial some infos stream.serial (name); stream.serial (pseudo); // Open a new node header named Address stream.xmlPushBegin ("Address"); // Set a property name stream.xmlSetAttrib ("Street") // Serial the property stream.serial ("Street"); // Close the new node header stream.xmlPushEnd (); // Serial in this node stream.serial (cityName); // Close the address node stream.xmlPop (); // Add a comment stream.xmlComment ("Hello"); // Close the identity node stream.xmlPop (); The result will be an xml document structured like this: <Identity> Corvazier Hulud <Address Street="rue du Faubourg Saint Antoine"> Paris <\Address> <!-- Hello --> <\Identity> Node header serials are the serialisations done between xmlPushBegin() and xmlPushEnd() call. There is some restrictions on them: Node header serials are only available for basic types (numbers and strings). xmlSetAttrib() must be called before node header serial. Note that XML documents only have ONE root node, so all serialisation must be done between a xmlPush() and a xmlPop() call. When a xml input stream will try to open a node, it will scan all currrent child nodes to find the good one. So input xml stream can skip unknown node.
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, T &value3, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, const char *nodeName)
template<class T> void	xmlSerial (T &value0, const char *nodeName)
BitField serialisation.
Unlike other serial method, The reading bitfield is returned!! If !this->isReading(), bf is returned. MUST use it simply like this: a= serialBitFieldX(a); // where X== 8, 16 or 32. NB: Performance warning: the data is stored as an uint8, uint16 or uint32, according to the method you use.
uint16	serialBitField16 (uint16 bf)
	Serialisation of bitfield <=16 bits.
uint32	serialBitField32 (uint32 bf)
	Serialisation of bitfield <=32 bits.
uint8	serialBitField8 (uint8 bf)
	Serialisation of bitfield <=8 bits.
standard STL containers serialisation. Elements must be pointers on a IStreamable object.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPtr()
template<class T> void	serialCheck (const T &value)
template<class T> void	serialContPolyPtr (std::multiset< T > &cont)
template<class T> void	serialContPolyPtr (std::set< T > &cont)
template<class T> void	serialContPolyPtr (std::deque< T > &cont)
template<class T> void	serialContPolyPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPolyPtr (std::vector< T, Allocator > &cont)
template<class T> void	serialPolyPtr (T *&ptr)
template<class T> void	serialPtr (T *&ptr)
uint	serialVersion (uint currentVersion)
standard STL containers serialisation. Elements must be pointers on a base type (uint...) or on a
object providing "void serial(IStream&)" method. Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPolyPtr()
template<class T> void	serialContPtr (std::multiset< T > &cont)
template<class T> void	serialContPtr (std::set< T > &cont)
template<class T> void	serialContPtr (std::deque< T > &cont)
template<class T> void	serialContPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPtr (std::vector< T, Allocator > &cont)
is the name of the node to open
xmlPushBegin() open recurcively a new node and open its header. You must call xmlPushEnd() to close the header and xmlPop() to close this node. Returns: true if you can open the node header, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlBreakLine ()
bool	xmlComment (const char *comment)
bool	xmlPop ()
bool	xmlPushBegin (const char *name)
bool	xmlPushEnd ()
bool	xmlSetAttrib (const char *name)
is the name of the node to open
xmlPush() open recurcively a new node. You must call xmlPop to close this node. Returns: true if you can open the node, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlPush (const char *name)
XML user interface
Those functions are used to add information in your stream to structure it like a XML document. Exemple of a serial sequence : // Start the opening of a new node named Identity stream.xmlPush ("Identity") // Serial some infos stream.serial (name); stream.serial (pseudo); // Open a new node header named Address stream.xmlPushBegin ("Address"); // Set a property name stream.xmlSetAttrib ("Street") // Serial the property stream.serial ("Street"); // Close the new node header stream.xmlPushEnd (); // Serial in this node stream.serial (cityName); // Close the address node stream.xmlPop (); // Add a comment stream.xmlComment ("Hello"); // Close the identity node stream.xmlPop (); The result will be an xml document structured like this: <Identity> Corvazier Hulud <Address Street="rue du Faubourg Saint Antoine"> Paris <\Address> <!-- Hello --> <\Identity> Node header serials are the serialisations done between xmlPushBegin() and xmlPushEnd() call. There is some restrictions on them: Node header serials are only available for basic types (numbers and strings). xmlSetAttrib() must be called before node header serial. Note that XML documents only have ONE root node, so all serialisation must be done between a xmlPush() and a xmlPop() call. When a xml input stream will try to open a node, it will scan all currrent child nodes to find the good one. So input xml stream can skip unknown node.
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, T &value3, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, const char *nodeName)
template<class T> void	xmlSerial (T &value0, const char *nodeName)
BitField serialisation.
Unlike other serial method, The reading bitfield is returned!! If !this->isReading(), bf is returned. MUST use it simply like this: a= serialBitFieldX(a); // where X== 8, 16 or 32. NB: Performance warning: the data is stored as an uint8, uint16 or uint32, according to the method you use.
uint16	serialBitField16 (uint16 bf)
	Serialisation of bitfield <=16 bits.
uint32	serialBitField32 (uint32 bf)
	Serialisation of bitfield <=32 bits.
uint8	serialBitField8 (uint8 bf)
	Serialisation of bitfield <=8 bits.
standard STL containers serialisation. Elements must be pointers on a IStreamable object.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPtr()
template<class T> void	serialCheck (const T &value)
template<class T> void	serialContPolyPtr (std::multiset< T > &cont)
template<class T> void	serialContPolyPtr (std::set< T > &cont)
template<class T> void	serialContPolyPtr (std::deque< T > &cont)
template<class T> void	serialContPolyPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPolyPtr (std::vector< T, Allocator > &cont)
template<class T> void	serialPolyPtr (T *&ptr)
template<class T> void	serialPtr (T *&ptr)
uint	serialVersion (uint currentVersion)
standard STL containers serialisation. Elements must be pointers on a base type (uint...) or on a
object providing "void serial(IStream&)" method. Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPolyPtr()
template<class T> void	serialContPtr (std::multiset< T > &cont)
template<class T> void	serialContPtr (std::set< T > &cont)
template<class T> void	serialContPtr (std::deque< T > &cont)
template<class T> void	serialContPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPtr (std::vector< T, Allocator > &cont)
is the name of the node to open
xmlPushBegin() open recurcively a new node and open its header. You must call xmlPushEnd() to close the header and xmlPop() to close this node. Returns: true if you can open the node header, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlBreakLine ()
bool	xmlComment (const char *comment)
bool	xmlPop ()
bool	xmlPushBegin (const char *name)
bool	xmlPushEnd ()
bool	xmlSetAttrib (const char *name)
is the name of the node to open
xmlPush() open recurcively a new node. You must call xmlPop to close this node. Returns: true if you can open the node, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlPush (const char *name)
XML user interface
Those functions are used to add information in your stream to structure it like a XML document. Exemple of a serial sequence : // Start the opening of a new node named Identity stream.xmlPush ("Identity") // Serial some infos stream.serial (name); stream.serial (pseudo); // Open a new node header named Address stream.xmlPushBegin ("Address"); // Set a property name stream.xmlSetAttrib ("Street") // Serial the property stream.serial ("Street"); // Close the new node header stream.xmlPushEnd (); // Serial in this node stream.serial (cityName); // Close the address node stream.xmlPop (); // Add a comment stream.xmlComment ("Hello"); // Close the identity node stream.xmlPop (); The result will be an xml document structured like this: <Identity> Corvazier Hulud <Address Street="rue du Faubourg Saint Antoine"> Paris <\Address> <!-- Hello --> <\Identity> Node header serials are the serialisations done between xmlPushBegin() and xmlPushEnd() call. There is some restrictions on them: Node header serials are only available for basic types (numbers and strings). xmlSetAttrib() must be called before node header serial. Note that XML documents only have ONE root node, so all serialisation must be done between a xmlPush() and a xmlPop() call. When a xml input stream will try to open a node, it will scan all currrent child nodes to find the good one. So input xml stream can skip unknown node.
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, T &value3, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, const char *nodeName)
template<class T> void	xmlSerial (T &value0, const char *nodeName)
Base type serialisation.
Those method are a specialisation of template method "void serial(T&)".
virtual void	serial (ucstring &b)
virtual void	serial (std::string &b)
virtual void	serial (char &b)
virtual void	serial (bool &b)
virtual void	serial (double &b)
virtual void	serial (float &b)
virtual void	serial (sint64 &b)
virtual void	serial (uint64 &b)
virtual void	serial (sint32 &b)
virtual void	serial (uint32 &b)
virtual void	serial (sint16 &b)
virtual void	serial (uint16 &b)
virtual void	serial (sint8 &b)
virtual void	serial (uint8 &b)
BitField serialisation.
Unlike other serial method, The reading bitfield is returned!! If !this->isReading(), bf is returned. MUST use it simply like this: a= serialBitFieldX(a); // where X== 8, 16 or 32. NB: Performance warning: the data is stored as an uint8, uint16 or uint32, according to the method you use.
uint16	serialBitField16 (uint16 bf)
	Serialisation of bitfield <=16 bits.
uint32	serialBitField32 (uint32 bf)
	Serialisation of bitfield <=32 bits.
uint8	serialBitField8 (uint8 bf)
	Serialisation of bitfield <=8 bits.
standard STL containers serialisation. Elements must be pointers on a IStreamable object.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPtr()
template<class T> void	serialCheck (const T &value)
template<class T> void	serialContPolyPtr (std::multiset< T > &cont)
template<class T> void	serialContPolyPtr (std::set< T > &cont)
template<class T> void	serialContPolyPtr (std::deque< T > &cont)
template<class T> void	serialContPolyPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPolyPtr (std::vector< T, Allocator > &cont)
template<class T> void	serialPolyPtr (T *&ptr)
template<class T> void	serialPtr (T *&ptr)
uint	serialVersion (uint currentVersion)
standard STL containers serialisation.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<>, map<>, multimap<> Support up to sint32 length containers. See also: serialContPtr() serialContPolyPtr()
template<class T, class Allocator> void	serialCont (std::vector< T, Allocator > &cont)
	Specialisation of serialCont() for vector<bool>.
standard STL containers serialisation. Elements must be pointers on a base type (uint...) or on a
object providing "void serial(IStream&)" method. Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPolyPtr()
template<class T> void	serialContPtr (std::multiset< T > &cont)
template<class T> void	serialContPtr (std::set< T > &cont)
template<class T> void	serialContPtr (std::deque< T > &cont)
template<class T> void	serialContPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPtr (std::vector< T, Allocator > &cont)
is the name of the node to open
xmlPushBegin() open recurcively a new node and open its header. You must call xmlPushEnd() to close the header and xmlPop() to close this node. Returns: true if you can open the node header, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlBreakLine ()
bool	xmlComment (const char *comment)
bool	xmlPop ()
bool	xmlPushBegin (const char *name)
bool	xmlPushEnd ()
bool	xmlSetAttrib (const char *name)
is the name of the node to open
xmlPush() open recurcively a new node. You must call xmlPop to close this node. Returns: true if you can open the node, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlPush (const char *name)
XML user interface
Those functions are used to add information in your stream to structure it like a XML document. Exemple of a serial sequence : // Start the opening of a new node named Identity stream.xmlPush ("Identity") // Serial some infos stream.serial (name); stream.serial (pseudo); // Open a new node header named Address stream.xmlPushBegin ("Address"); // Set a property name stream.xmlSetAttrib ("Street") // Serial the property stream.serial ("Street"); // Close the new node header stream.xmlPushEnd (); // Serial in this node stream.serial (cityName); // Close the address node stream.xmlPop (); // Add a comment stream.xmlComment ("Hello"); // Close the identity node stream.xmlPop (); The result will be an xml document structured like this: <Identity> Corvazier Hulud <Address Street="rue du Faubourg Saint Antoine"> Paris <\Address> <!-- Hello --> <\Identity> Node header serials are the serialisations done between xmlPushBegin() and xmlPushEnd() call. There is some restrictions on them: Node header serials are only available for basic types (numbers and strings). xmlSetAttrib() must be called before node header serial. Note that XML documents only have ONE root node, so all serialisation must be done between a xmlPush() and a xmlPop() call. When a xml input stream will try to open a node, it will scan all currrent child nodes to find the good one. So input xml stream can skip unknown node.
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, T &value3, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, const char *nodeName)
template<class T> void	xmlSerial (T &value0, const char *nodeName)
BitField serialisation.
Unlike other serial method, The reading bitfield is returned!! If !this->isReading(), bf is returned. MUST use it simply like this: a= serialBitFieldX(a); // where X== 8, 16 or 32. NB: Performance warning: the data is stored as an uint8, uint16 or uint32, according to the method you use.
uint16	serialBitField16 (uint16 bf)
	Serialisation of bitfield <=16 bits.
uint32	serialBitField32 (uint32 bf)
	Serialisation of bitfield <=32 bits.
uint8	serialBitField8 (uint8 bf)
	Serialisation of bitfield <=8 bits.
standard STL containers serialisation. Elements must be pointers on a IStreamable object.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPtr()
template<class T> void	serialCheck (const T &value)
template<class T> void	serialContPolyPtr (std::multiset< T > &cont)
template<class T> void	serialContPolyPtr (std::set< T > &cont)
template<class T> void	serialContPolyPtr (std::deque< T > &cont)
template<class T> void	serialContPolyPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPolyPtr (std::vector< T, Allocator > &cont)
template<class T> void	serialPolyPtr (T *&ptr)
template<class T> void	serialPtr (T *&ptr)
uint	serialVersion (uint currentVersion)
standard STL containers serialisation. Elements must be pointers on a base type (uint...) or on a
object providing "void serial(IStream&)" method. Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<> Support up to sint32 length containers. See also: serialCont() serialContPolyPtr()
template<class T> void	serialContPtr (std::multiset< T > &cont)
template<class T> void	serialContPtr (std::set< T > &cont)
template<class T> void	serialContPtr (std::deque< T > &cont)
template<class T> void	serialContPtr (std::list< T > &cont)
template<class T, class Allocator> void	serialContPtr (std::vector< T, Allocator > &cont)
is the name of the node to open
xmlPushBegin() open recurcively a new node and open its header. You must call xmlPushEnd() to close the header and xmlPop() to close this node. Returns: true if you can open the node header, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlBreakLine ()
bool	xmlComment (const char *comment)
bool	xmlPop ()
bool	xmlPushBegin (const char *name)
bool	xmlPushEnd ()
bool	xmlSetAttrib (const char *name)
is the name of the node to open
xmlPush() open recurcively a new node. You must call xmlPop to close this node. Returns: true if you can open the node, false if the stream is between a xmlPushBegin() and a xmlPushEnd() call.
bool	xmlPush (const char *name)
XML user interface
Those functions are used to add information in your stream to structure it like a XML document. Exemple of a serial sequence : // Start the opening of a new node named Identity stream.xmlPush ("Identity") // Serial some infos stream.serial (name); stream.serial (pseudo); // Open a new node header named Address stream.xmlPushBegin ("Address"); // Set a property name stream.xmlSetAttrib ("Street") // Serial the property stream.serial ("Street"); // Close the new node header stream.xmlPushEnd (); // Serial in this node stream.serial (cityName); // Close the address node stream.xmlPop (); // Add a comment stream.xmlComment ("Hello"); // Close the identity node stream.xmlPop (); The result will be an xml document structured like this: <Identity> Corvazier Hulud <Address Street="rue du Faubourg Saint Antoine"> Paris <\Address> <!-- Hello --> <\Identity> Node header serials are the serialisations done between xmlPushBegin() and xmlPushEnd() call. There is some restrictions on them: Node header serials are only available for basic types (numbers and strings). xmlSetAttrib() must be called before node header serial. Note that XML documents only have ONE root node, so all serialisation must be done between a xmlPush() and a xmlPop() call. When a xml input stream will try to open a node, it will scan all currrent child nodes to find the good one. So input xml stream can skip unknown node.
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, T &value3, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, T &value2, const char *nodeName)
template<class T> void	xmlSerial (T &value0, T &value1, const char *nodeName)
template<class T> void	xmlSerial (T &value0, const char *nodeName)
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)
XML implementation interface
void	setInOut (bool inputStream)
void	setXMLMode (bool on)
virtual bool	xmlBreakLineInternal ()
	xmlBreakLine implementation
virtual bool	xmlCommentInternal (const char *comment)
	xmlComment implementation
virtual bool	xmlPopInternal ()
	xmlPop implementation
virtual bool	xmlPushBeginInternal (const char *name)
	xmlPushBegin implementation
virtual bool	xmlPushEndInternal ()
	xmlPushEnd implementation
virtual bool	xmlSetAttribInternal (const char *name)
	xmlBreakLine implementation
XML implementation interface
void	setInOut (bool inputStream)
void	setXMLMode (bool on)
virtual bool	xmlBreakLineInternal ()
	xmlBreakLine implementation
virtual bool	xmlCommentInternal (const char *comment)
	xmlComment implementation
virtual bool	xmlPopInternal ()
	xmlPop implementation
virtual bool	xmlPushBeginInternal (const char *name)
	xmlPushBegin implementation
virtual bool	xmlPushEndInternal ()
	xmlPushEnd implementation
virtual bool	xmlSetAttribInternal (const char *name)
	xmlBreakLine implementation
XML implementation interface
void	setInOut (bool inputStream)
void	setXMLMode (bool on)
virtual bool	xmlBreakLineInternal ()
	xmlBreakLine implementation
virtual bool	xmlCommentInternal (const char *comment)
	xmlComment implementation
virtual bool	xmlPopInternal ()
	xmlPop implementation
virtual bool	xmlPushBeginInternal (const char *name)
	xmlPushBegin implementation
virtual bool	xmlPushEndInternal ()
	xmlPushEnd implementation
virtual bool	xmlSetAttribInternal (const char *name)
	xmlBreakLine implementation
XML implementation interface
void	setInOut (bool inputStream)
void	setXMLMode (bool on)
virtual bool	xmlBreakLineInternal ()
	xmlBreakLine implementation
virtual bool	xmlCommentInternal (const char *comment)
	xmlComment implementation
virtual bool	xmlPopInternal ()
	xmlPop implementation
virtual bool	xmlPushBeginInternal (const char *name)
	xmlPushBegin implementation
virtual bool	xmlPushEndInternal ()
	xmlPushEnd implementation
virtual bool	xmlSetAttribInternal (const char *name)
	xmlBreakLine implementation
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. { begin, current, end };

---

Constructor & Destructor Documentation

NLMISC::CStringStream::CStringStream (  bool  inputStream = false, uint32  defaultcapacity = 0 )  [inline]

Initialization constructor. Definition at line 48 of file string_stream.h. References uint32. : CMemStream( inputStream, defaultcapacity ) {}

NLMISC::CStringStream::CStringStream (  const CStringStream &  other  )  [inline]

Copy constructor. Definition at line 51 of file string_stream.h. : CMemStream( other ) {}

---

Member Function Documentation

const uint8* NLMISC::CMemStream::buffer (   )  const [inline, inherited]

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(). { return _Buffer.getPtr(); /* if ( _Buffer.empty() ) { return NULL; } else { return &(*_Buffer.begin()); }*/ }

uint8* NLMISC::CMemStream::bufferToFill (  uint32  msgsize  )  [inline, inherited]

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 NLMISC::CMemStream::_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(). { #ifdef NL_DEBUG nlassert( isReading() ); #endif if ( msgsize == 0 ) return NULL; _Buffer.resize( msgsize ); _BufPos = _Buffer.getPtr(); /*if ( ! isReading() ) _BufPos += msgsize;*/ return _Buffer.getPtr(); }

virtual void NLMISC::CMemStream::clear (  void   )  [inline, virtual, inherited]

Clears the message. Reimplemented in NLMISC::CBitMemStream, and NLNET::CMessage. Definition at line 201 of file mem_stream.h. References NLMISC::CMemStream::_BufPos, NLMISC::CMemStream::_DefaultCapacity, NLMISC::CObjectVector< uint8, false >::clear(), NLMISC::CObjectVector< uint8, false >::getPtr(), NLMISC::IStream::isReading(), NLMISC::CMemStream::resetPtrTable(), and NLMISC::CObjectVector< uint8, false >::resize(). Referenced by NLPACS::CGlobalRetriever::CLrLoader::run(). { resetPtrTable(); _Buffer.clear(); if (!isReading()) { _Buffer.resize (_DefaultCapacity); } _BufPos = _Buffer.getPtr(); }

template<class T> void NLMISC::CMemStream::fastRead (  T &  value  )  [inline, inherited]

Definition at line 404 of file mem_stream.h. References NLMISC::CMemStream::_BufPos, NLMISC::CMemStream::length(), NLMISC::CMemStream::lengthS(), and value. { //nldebug( "MEMSTREAM: Reading %u-byte value in %p at pos %u", sizeof(value), this, _BufPos - _Buffer.getPtr() ); // Check that we don't read more than there is to read if ( lengthS()+sizeof(value) > length() ) // calls virtual length (cf. sub messages) { throw EStreamOverflow(); } // Serialize in value = *(T*)_BufPos; _BufPos += sizeof(value); }

template<class T> void NLMISC::CMemStream::fastSerial (  T &  val  )  [inline, inherited]

Definition at line 371 of file mem_stream.h. References NLMISC::CMemStream::_BufPos, NLMISC::CMemStream::increaseBufferIfNecessary(), NLMISC::IStream::isReading(), NLMISC::CMemStream::length(), and NLMISC::CMemStream::lengthS(). Referenced by NLMISC::CMemStream::serial(). { #ifdef NL_LITTLE_ENDIAN if(isReading()) { // Check that we don't read more than there is to read // TODO OPTIM we can remove the check if we want to be faster (50ms->43ms for 1 million serial) if ( lengthS()+sizeof(T) > length() ) // calls virtual length (cf. sub messages) throw EStreamOverflow(); // Serialize in val = *(T*)_BufPos; } else { increaseBufferIfNecessary (sizeof(T)); *(T*)_BufPos = val; } _BufPos += sizeof (T); #else // NL_LITTLE_ENDIAN IStream::serial( val ); #endif // NL_LITTLE_ENDIAN }

template<class T> void NLMISC::CMemStream::fastWrite (  const T &  value  )  [inline, inherited]

Definition at line 395 of file mem_stream.h. References NLMISC::CMemStream::_BufPos, NLMISC::CMemStream::increaseBufferIfNecessary(), and value. { //nldebug( "MEMSTREAM: Writing %u-byte value in %p at pos %u", sizeof(value), this, _BufPos - _Buffer.getPtr() ); increaseBufferIfNecessary (sizeof(T)); *(T*)_BufPos = value; _BufPos += sizeof (T); }

void NLMISC::CMemStream::fill (  const uint8 *  srcbuf, uint32  len )  [inline, inherited]

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 NLMISC::CMemStream::_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(). { if (len == 0) return; _Buffer.resize( len ); CFastMem::memcpy( _Buffer.getPtr(), srcbuf, len ); if (isReading()) { _BufPos = _Buffer.getPtr(); } else { _BufPos = _Buffer.getPtr() + _Buffer.size(); } }

sint32 NLMISC::CMemStream::getPos (  void   )  const [inline, inherited]

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 NLMISC::CMemStream::_BufPos, NLMISC::CObjectVector< uint8, false >::getPtr(), and sint32. { return _BufPos - _Buffer.getPtr(); }

virtual sint32 NLMISC::CMemStream::getPos (  void   )  throw (EStream) [inline, virtual, inherited]

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 NLMISC::CMemStream::_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(). { return _BufPos - _Buffer.getPtr(); }

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(). { return ""; }

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. { throwOnOlder=_ThrowOnOlder; throwOnNewer=_ThrowOnNewer; }

void NLMISC::CMemStream::increaseBufferIfNecessary (  uint32  len  )  [inline, inherited]

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

virtual void NLMISC::CMemStream::invert (   )  [inline, virtual, inherited]

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 NLMISC::CMemStream::_BufPos, NLMISC::CObjectVector< uint8, false >::getPtr(), NLMISC::IStream::isReading(), NLMISC::CMemStream::lengthR(), NLMISC::CMemStream::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(). { if ( isReading() ) { // In->Out: We want to write (serialize out) what we have read (serialized in) uint32 sizeOfReadStream = lengthR(); resetPtrTable(); setInOut( false ); _BufPos = _Buffer.getPtr() + sizeOfReadStream; } else { // Out->In: We want to read (serialize in) what we have written (serialized out) resetPtrTable(); setInOut( true ); _Buffer.resize (_BufPos - _Buffer.getPtr()); _BufPos = _Buffer.getPtr(); } }

bool NLMISC::IStream::isReading (   )  const [inline, inherited]

Is this stream a Read/Input stream? Definition at line 64 of file stream_inline.h. References NLMISC::IStream::_InputStream. Referenced by NLNET::CMessage::assignFromSubMessage(), NLMISC::CMemStream::bufferToFill(), NL3D::CParticleSystemShape::buildFromPS(), NLNET::CMessage::clear(), NLMISC::CMemStream::clear(), NLNET::CMessage::CMessage(), NLMISC::CBitMemStream::displayStream(), NLMISC::CMemStream::fastSerial(), NLMISC::CMemStream::fill(), NL3D::CParticleSystemShape::flushTextures(), NLMISC::CBitMemStream::getSerialItem(), NLMISC::CBitMemStream::increaseBufferIfNecessary(), NLMISC::COXml::init(), NL3D::CParticleSystemShape::instanciatePS(), NLMISC::CBitMemStream::internalSerial(), NLNET::CMessage::invert(), NLMISC::CMemStream::invert(), NLMISC::CBitMemStream::invert(), NLNET::CMessage::length(), NLMISC::CMemStream::length(), NLMISC::CBitMemStream::length(), NLMISC::CBitmap::load(), NLMISC::CBitmap::loadSize(), NLNET::CMessage::lockSubMessage(), NLNET::CMessage::operator=(), NLMISC::CBitMemStream::pointNextByte(), NLMISC::CMemStream::poke(), NLMISC::CBitMemStream::poke(), NLMISC::CBitMemStream::pokeBits(), NLMISC::CBitMemStream::readBits(), NLMISC::CBitmap::readTGA(), NLNET::CMessage::readTypeAtCurrentPos(), NLMISC::CMemStream::reserve(), NLMISC::CBitMemStream::reserveBits(), NLMISC::CBitMemStream::resetBufPos(), NLPACS::CGlobalRetriever::CLrLoader::run(), NL3D::CZone::serial(), NL3D::CVegetableShape::serial(), NLPACS::CSurfaceQuadTree::serial(), NLPACS::CQuadBranch::serial(), NL3D::CSurfaceLightGrid::CCellCorner::serial(), serial(), NLMISC::IStream::serial(), NL3D::CInstanceGroup::serial(), NL3D::CInstanceGroup::CInstance::serial(), NLPACS::CRetrieverInstance::serial(), NLPACS::CRetrieverBank::serial(), NL3D::CPSAttrib< T >::serial(), NL3D::CPortal::serial(), NL3D::CPointLightNamed::serial(), NL3D::CPointLight::serial(), NL3D::CPatch::serial(), NLMISC::CObjectVector< sint8, false >::serial(), NLMISC::COXml::serial(), NLNET::TMessageRecord::serial(), NL3D::CMeshMRMSkinnedGeom::serial(), NLMISC::CMemStream::serial(), NLMISC::CMatrix::serial(), NL3D::CMaterial::CLightMap::serial(), NL3D::CMaterial::serial(), NLNET::CInetAddress::serial(), NL3D::CHLSTextureBank::serial(), NLPACS::CGlobalRetriever::serial(), NLPACS::CEdgeQuad::serial(), NL3D::CCluster::serial(), NLPACS::CChainQuad::serial(), NLPACS::COrderedChain::serial(), NLMISC::CBitSet::serial(), NLMISC::CBitMemStream::serial(), NL3D::CMaterialBase::CAnimatedTexture::serial(), NLMISC::CAABBoxExt::serial(), NL3D::CMaterial::CLightMap::serial2(), serialBit(), NLMISC::CMemStream::serialBit(), NLMISC::CBitMemStream::serialBit(), NLMISC::CMemStream::serialBuffer(), NLMISC::CBitMemStream::serialBuffer(), NLMISC::IStream::serialCheck(), serialCont(), NLMISC::IStream::serialCont(), NLMISC::CBitMemStream::serialCont(), NLMISC::IStream::serialEnum(), NL3D::CVertexBuffer::serialHeader(), serialHex(), NLMISC::CMemStream::serialHex(), NLMISC::IStream::serialIStreamable(), NL3D::CMeshMRMGeom::serialLodVertexData(), NLMISC::IStream::serialMap(), NLMISC::IStream::serialMemStream(), NLMISC::CBitMemStream::serialMemStream(), NLNET::CMessage::serialMessage(), NLMISC::IStream::serialMultimap(), NL3D::CVertexBuffer::serialOldV1Minus(), NLMISC::IStream::serialPtr(), serialSeparatedBufferIn(), NLMISC::CMemStream::serialSeparatedBufferIn(), serialSeparatedBufferOut(), NLMISC::COXml::serialSeparatedBufferOut(), NLMISC::CMemStream::serialSeparatedBufferOut(), NLMISC::IStream::serialSTLCont(), NLMISC::IStream::serialSTLContLen(), NLMISC::IStream::serialSTLContLenPolyPtr(), NLMISC::IStream::serialSTLContLenPtr(), NLMISC::IStream::serialSTLContPolyPtr(), NLMISC::IStream::serialSTLContPtr(), NL3D::CVertexBuffer::serialSubset(), NLMISC::IStream::serialVector(), NLMISC::IStream::serialVectorPolyPtr(), NLMISC::IStream::serialVectorPtr(), NLMISC::IStream::serialVersion(), NLNET::CMessage::setType(), NLNET::CMessage::unlockSubMessage(), NLMISC::CBitmap::writeTGA(), NLMISC::COXml::xmlBreakLineInternal(), NLMISC::COXml::xmlCommentInternal(), NLMISC::COXml::xmlPopInternal(), NLMISC::COXml::xmlPushBeginInternal(), NLMISC::COXml::xmlPushEndInternal(), and NLMISC::COXml::xmlSetAttribInternal(). { return _InputStream; }

bool NLMISC::IStream::isXML (   )  const [inline, inherited]

Definition at line 221 of file stream.h. References NLMISC::IStream::_XML. Referenced by NLMISC::CMemStream::serial(). { return _XML; }

virtual uint32 NLMISC::CMemStream::length (   )  const [inline, virtual, inherited]

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(), NLMISC::CMemStream::lengthR(), NLMISC::CMemStream::lengthS(), and uint32. Referenced by NLMISC::CMemStream::fastRead(), NLMISC::CMemStream::fastSerial(), NLMISC::CMemStream::resize(), NLMISC::CMemStream::serialBuffer(), NLMISC::IStream::serialMemStream(), serialSeparatedBufferIn(), and NLMISC::CMemStream::serialSeparatedBufferIn(). { if ( isReading() ) { return lengthR(); } else { return lengthS(); } }

uint32 NLMISC::CMemStream::lengthR (   )  const [inline, protected, inherited]

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 NLMISC::CMemStream::size(), and uint32. Referenced by NLMISC::CBitMemStream::getSerialItem(), NLMISC::CBitMemStream::internalSerial(), NLMISC::CMemStream::invert(), NLMISC::CMemStream::length(), and NLMISC::CBitMemStream::length(). { return size(); }

uint32 NLMISC::CMemStream::lengthS (   )  const [inline, protected, inherited]

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

CStringStream& NLMISC::CStringStream::operator= (  const CStringStream &  other  )  [inline]

Assignment operator. Definition at line 54 of file string_stream.h. { CMemStream::operator=( other ); return *this; }

template<class T> void NLMISC::CMemStream::poke (  T  value, sint32  pos )  [inline, inherited]

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 NLMISC::CMemStream::_BufPos, NLMISC::CObjectVector< uint8, false >::getPtr(), NLMISC::IStream::isReading(), nlassert, sint32, uint8, and value. { if ( ! isReading() ) { uint8 *pokeBufPos = _Buffer.getPtr() + pos; nlassert( pokeBufPos + sizeof(T) <= _BufPos ); *(T*)pokeBufPos = value; } }

sint32 NLMISC::CMemStream::reserve (  uint  len  )  [inline, inherited]

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 NLMISC::CMemStream::_BufPos, NLMISC::CObjectVector< uint8, false >::getPtr(), NLMISC::CMemStream::increaseBufferIfNecessary(), NLMISC::IStream::isReading(), len, sint32, and uint. { sint32 pos = _BufPos - _Buffer.getPtr(); if ( ! isReading() ) { increaseBufferIfNecessary( len ); _BufPos += len; } return pos; }

void NLMISC::CMemStream::resetBufPos (   )  [inline, inherited]

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 NLMISC::CMemStream::_BufPos, and NLMISC::CObjectVector< uint8, false >::getPtr(). Referenced by NLMISC::IStream::serialMemStream(). { _BufPos = _Buffer.getPtr(); }

void NLMISC::CMemStream::resetPtrTable (   )  [inline, inherited]

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

void NLMISC::CMemStream::resize (  uint32  size  )  [inherited]

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

bool NLMISC::CMemStream::seek (  sint32  offset, TSeekOrigin  origin )  throw (EStream) [virtual, inherited]

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(). { switch (origin) { case begin: if (offset > (sint)length()) return false; if (offset < 0) return false; _BufPos=_Buffer.getPtr()+offset; break; case current: if (getPos ()+offset > (sint)length()) return false; if (getPos ()+offset < 0) return false; _BufPos+=offset; break; case end: if (offset < -(sint)length()) return false; if (offset > 0) return false; _BufPos=_Buffer.getPtr()+_Buffer.size()+offset; break; } return true; }

void NLMISC::CStringStream::serial (  ucstring &  b  )  [virtual]

Reimplemented from NLMISC::CMemStream. Definition at line 316 of file string_stream.cpp. References NLMISC::IStream::isReading(), len, NLMISC::SEPARATOR, serial(), NLMISC::CMemStream::serialBuffer(), sint, sint32, and uint8. { sint32 len=0; // Read/Write the length. if(isReading()) { serial(len); b.resize(len); } else { len= b.size(); serial(len); } // Read/Write the string. for(sint i=0;i<len;i++) serialBuffer( (uint8*)&b[i], sizeof( sizeof(b[i]) ) ); char sep = SEPARATOR; serialBuffer( (uint8*)&sep, 1 ); }

void NLMISC::CStringStream::serial (  std::string &  b  )  [virtual]

Reimplemented from NLMISC::CMemStream. Definition at line 290 of file string_stream.cpp. References NLMISC::IStream::isReading(), len, nlassert, NLMISC::SEPARATOR, serial(), NLMISC::CMemStream::serialBuffer(), sint, sint32, and uint8. { sint32 len=0; // Read/Write the length. if(isReading()) { serial(len); nlassert( len<1000000 ); // limiting string size b.resize(len); } else { len= b.size(); serial(len); } // Read/Write the string. for(sint i=0;i<len;i++) serialBuffer( (uint8*)&(b[i]), sizeof(b[i]) ); char sep = SEPARATOR; serialBuffer( (uint8*)&sep, 1 ); }

void NLMISC::CStringStream::serial (  char &  b  )  [virtual]

Reimplemented from NLMISC::CMemStream. Definition at line 271 of file string_stream.cpp. References NLMISC::IStream::isReading(), NLMISC::SEPARATOR, NLMISC::CMemStream::serialBuffer(), and uint8. { char buff [2]; if ( isReading() ) { serialBuffer( (uint8*)buff, 2 ); b = buff[0]; } else { buff[0] = b; buff[1] = SEPARATOR; serialBuffer( (uint8*)buff, 2 ); } }

void NLMISC::CStringStream::serial (  bool &  b  )  [virtual]

Reimplemented from NLMISC::CMemStream. Definition at line 246 of file string_stream.cpp. References serialBit(). { serialBit(b); }

void NLMISC::CStringStream::serial (  double &  b  )  [virtual]

Reimplemented from NLMISC::CMemStream. Definition at line 233 of file string_stream.cpp. References NLMISC::IStream::isReading(), readnumber, and writenumber. { if ( isReading() ) { readnumber( b, double, 128, atof ); // } else { writenumber( b, "%f", 128 ); } }

void NLMISC::CStringStream::serial (  float &  b  )  [virtual]

Reimplemented from NLMISC::CMemStream. Definition at line 220 of file string_stream.cpp. References NLMISC::IStream::isReading(), readnumber, and writenumber. { if ( isReading() ) { readnumber( b, float, 128, atof ); // ? } else { writenumber( (double)b, "%f", 128 ); } }

void NLMISC::CStringStream::serial (  sint64 &  b  )  [virtual]

Reimplemented from NLMISC::CMemStream. Definition at line 207 of file string_stream.cpp. References NLMISC::IStream::isReading(), NL_I64, readnumber, sint64, and writenumber. { if ( isReading() ) { readnumber( b, sint64, 20, atoiInt64 ); // -9223372036854775808 } else { writenumber( b, "%"NL_I64"d", 20 ); } }

void NLMISC::CStringStream::serial (  uint64 &  b  )  [virtual]

Reimplemented from NLMISC::CMemStream. Definition at line 194 of file string_stream.cpp. References NLMISC::IStream::isReading(), NL_I64, readnumber, uint64, and writenumber. { if ( isReading() ) { readnumber( b, uint64, 20, atoiInt64 ); // 18446744073709551615 } else { writenumber( b, "%"NL_I64"u", 20 ); } }

void NLMISC::CStringStream::serial (  sint32 &  b  )  [virtual]

Reimplemented from NLMISC::CMemStream. Definition at line 181 of file string_stream.cpp. References NLMISC::IStream::isReading(), readnumber, sint32, and writenumber. { if ( isReading() ) { readnumber( b, sint32, 11, atoi ); // -2147483648 } else { writenumber( b, "%d", 11 ); } }

void NLMISC::CStringStream::serial (  uint32 &  b  )  [virtual]

Reimplemented from NLMISC::CMemStream. Definition at line 168 of file string_stream.cpp. References NLMISC::atoui(), NLMISC::IStream::isReading(), readnumber, uint32, and writenumber. { if ( isReading() ) { readnumber( b, uint32, 10, atoui ); // 4294967295 } else { writenumber( b, "%u", 10 ); } }

void NLMISC::CStringStream::serial (  sint16 &  b  )  [virtual]

Reimplemented from NLMISC::CMemStream. Definition at line 155 of file string_stream.cpp. References NLMISC::IStream::isReading(), readnumber, sint16, and writenumber. { if ( isReading() ) { readnumber( b, sint16, 6, atoi ); // -32768 } else { writenumber( b, "%hd", 6 ); } }

void NLMISC::CStringStream::serial (  uint16 &  b  )  [virtual]

Reimplemented from NLMISC::CMemStream. Definition at line 141 of file string_stream.cpp. References NLMISC::IStream::isReading(), readnumber, uint16, and writenumber. { // No byte swapping in text mode if ( isReading() ) { readnumber( b, uint16, 5, atoi ); // 65535 } else { writenumber( b, "%hu", 5 ); } }

void NLMISC::CStringStream::serial (  sint8 &  b  )  [virtual]

Reimplemented from NLMISC::CMemStream. Definition at line 128 of file string_stream.cpp. References NLMISC::IStream::isReading(), readnumber, sint16, sint8, and writenumber. { if ( isReading() ) { readnumber( b, sint8, 4, atoi ); // -128 } else { writenumber( (sint16)b, "%hd", 4 ); } }

void NLMISC::CStringStream::serial (  uint8 &  b  )  [virtual]

Reimplemented from NLMISC::CMemStream. Definition at line 115 of file string_stream.cpp. References NLMISC::IStream::isReading(), readnumber, uint16, uint8, and writenumber. { if ( isReading() ) { readnumber( b, uint8, 3, atoi ); // 255 } else { writenumber( (uint16)b,"%hu", 3 ); } }

template<class T0, class T1, class T2, class T3, class T4, class T5> void NLMISC::CStringStream::serial (  T0 &  a, T1 &  b, T2 &  c, T3 &  d, T4 &  e, T5 &  f )  [inline]

Reimplemented from NLMISC::CMemStream. Definition at line 97 of file string_stream.h. References serial(). { 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::CStringStream::serial (  T0 &  a, T1 &  b, T2 &  c, T3 &  d, T4 &  e )  [inline]

Reimplemented from NLMISC::CMemStream. Definition at line 94 of file string_stream.h. References serial(). { serial(a); serial(b); serial(c); serial(d); serial(e);}

template<class T0, class T1, class T2, class T3> void NLMISC::CStringStream::serial (  T0 &  a, T1 &  b, T2 &  c, T3 &  d )  [inline]

Reimplemented from NLMISC::CMemStream. Definition at line 91 of file string_stream.h. References serial(). { serial(a); serial(b); serial(c); serial(d);}

template<class T0, class T1, class T2> void NLMISC::CStringStream::serial (  T0 &  a, T1 &  b, T2 &  c )  [inline]

Reimplemented from NLMISC::CMemStream. Definition at line 88 of file string_stream.h. References serial(). { serial(a); serial(b); serial(c);}

template<class T0, class T1> void NLMISC::CStringStream::serial (  T0 &  a, T1 &  b )  [inline]

Reimplemented from NLMISC::CMemStream. Definition at line 85 of file string_stream.h. References serial(). { serial(a); serial(b);}

template<class T> void NLMISC::CStringStream::serial (  T &  obj  )  [inline]

Template serialisation (should take the one from IStream). Reimplemented from NLMISC::CMemStream. Definition at line 67 of file string_stream.h. Referenced by serial(), serialBit(), and serialCont(). { obj.serial(*this); }

void NLMISC::CStringStream::serialBit (  bool &  bit  )  [virtual]

Method inherited from IStream. Reimplemented from NLMISC::CMemStream. Definition at line 253 of file string_stream.cpp. References NLMISC::IStream::isReading(), serial(), and uint8. Referenced by serial(). { uint8 u; if ( isReading() ) { serial( u ); bit = (u!=0); } else { u = (uint8)bit; serial( u ); } }

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. { serial(bf); return bf; }

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. { serial(bf); return bf; }

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(). { serial(bf); return bf; }

void NLMISC::CMemStream::serialBuffer (  uint8 *  buf, uint  len )  [virtual, inherited]

Method inherited from IStream. Implements NLMISC::IStream. Reimplemented in NLMISC::CBitMemStream. Definition at line 73 of file mem_stream.cpp. References NLMISC::CMemStream::_BufPos, NLMISC::CMemStream::increaseBufferIfNecessary(), NLMISC::IStream::isReading(), len, NLMISC::CMemStream::length(), NLMISC::CMemStream::lengthS(), nlassert, uint, and uint8. Referenced by serial(), NLNET::TMessageRecord::serial(), NLMISC::CMemStream::serial(), and NLNET::CMessage::serialMessage(). { // commented for optimum performance nlassert (len > 0); nlassert (buf != NULL); if ( isReading() ) { // Check that we don't read more than there is to read if ( lengthS()+len > length() ) // calls virtual length (cf. sub messages) { throw EStreamOverflow(); } // Serialize in CFastMem::memcpy( buf, _BufPos, len ); _BufPos += len; } else { // Serialize out increaseBufferIfNecessary (len); /* uint32 oldBufferSize = _Buffer.size(); if (_BufPos - _Buffer.getPtr() + len > oldBufferSize) { // need to increase the buffer size uint32 pos = _BufPos - _Buffer.getPtr(); _Buffer.resize(oldBufferSize*2 + len); _BufPos = _Buffer.getPtr() + pos; } */ CFastMem::memcpy( _BufPos, buf, len ); _BufPos += len; /* _Buffer.resize( size ); _BufPos = _Buffer.end() - len; CFastMem::memcpy( &(*_BufPos), buf, len ); _BufPos = _Buffer.end();*/ } }

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. { serial (len); serialBuffer (buf, len); }

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(). { // Open a node xmlPush ("CHECK"); if (isReading()) { T read; serial (read); if (read!=value) throw EInvalidDataStream(*this); } else { serial (const_cast<T&>(value)); } // Close the node xmlPop (); }

template<class T, class Allocator> void NLMISC::IStream::serialCont (  std::vector< T, Allocator > &  cont  )  [inline, inherited]

Specialisation of serialCont() for vector<bool>. Definition at line 324 of file stream.h. References NLMISC::IStream::serialVector(). Referenced by NL3D::H_AUTO_DECL(), NLAISCRIPT::CLdbHeapMemberiOpCode::load(), NLAISCRIPT::CLdbStackMemberiOpCode::load(), NLAISCRIPT::CLdbMemberiOpCode::load(), NLAISCRIPT::CCallMethodi::load(), NLAISCRIPT::CCallStackMethodi::load(), NLAISCRIPT::CCallHeapMethodi::load(), NLAISCRIPT::CLibStackMemberMethod::load(), NLAISCRIPT::CLibCallMethodi::load(), NLAISCRIPT::CLibMemberMethodi::load(), NLAISCRIPT::CAffMemberiOpCode::load(), NLAISCRIPT::CAffHeapMemberiOpCode::load(), NLAISCRIPT::CLoadHeapObject::load(), NLAISCRIPT::CLoadStackObject::load(), NLAISCRIPT::CLoadSelfObject::load(), NLMISC::CEntityIdTranslator::load(), NLSOUND::CBackgroundSoundManager::load(), loadForm(), NLAISCRIPT::CLdbHeapMemberiOpCode::save(), NLAISCRIPT::CLdbStackMemberiOpCode::save(), NLAISCRIPT::CLdbMemberiOpCode::save(), NLAISCRIPT::CCallMethodi::save(), NLAISCRIPT::CCallStackMethodi::save(), NLAISCRIPT::CCallHeapMethodi::save(), NLAISCRIPT::CLibStackMemberMethod::save(), NLAISCRIPT::CLibCallMethodi::save(), NLAISCRIPT::CLibMemberMethodi::save(), NLAISCRIPT::CAffMemberiOpCode::save(), NLAISCRIPT::CAffHeapMemberiOpCode::save(), NLAISCRIPT::CLoadHeapObject::save(), NLAISCRIPT::CLoadStackObject::save(), NLAISCRIPT::CLoadSelfObject::save(), NLMISC::CEntityIdTranslator::save(), NLLIGO::CZoneRegion::serial(), NLLIGO::CZoneBankElement::serial(), NL3D::CZone::serial(), NL3D::CVegetableShape::serial(), NL3D::CTileVegetableDesc::serial(), NL3D::CSkeletonWeight::serial(), NL3D::CInstanceGroup::serial(), NL3D::CInstanceGroup::CInstance::serial(), NLPACS::CRetrieverInstance::serial(), NLPACS::CRetrieverBank::serial(), NLPACS::CRetrievableSurface::TLoop::serial(), NLPACS::CRetrievableSurface::serial(), NL3D::CPrimitiveBlock::serial(), NL3D::CPortal::serial(), NL3D::CPointLightNamedArray::serial(), NL3D::CPatch::serial(), NLMISC::CNoiseColorGradient::serial(), NL3D::CMeshMRMSkinnedGeom::CRdrPass::serial(), NL3D::CMeshMRMSkinnedGeom::CPackedVertexBuffer::serial(), NL3D::CMeshMRMSkinnedGeom::serial(), NL3D::CMeshBase::CLightMapInfoList::serial(), NL3D::CMeshBase::CLightInfoMapListV7::serial(), NL3D::CMeshGeom::CMatrixBlock::serial(), NL3D::CMaterial::serial(), NL3D::CLodCharacterTexture::serial(), NL3D::CLodCharacterShapeBank::serial(), NL3D::CLodCharacterShape::serial(), NL3D::CLodCharacterShape::CBoneInfluence::serial(), NL3D::CLodCharacterShape::CAnim::serial(), NL3D::CLodCharacterShapeBuild::serial(), NLPACS::CLocalRetriever::CTopology::serial(), NLPACS::CLocalRetriever::CTip::serial(), NLPACS::CLocalRetriever::serial(), NL3D::CIGSurfaceLight::serial(), NL3D::CHLSTextureBank::serial(), NL3D::CHLSColorTexture::serial(), NL3D::CHLSColorTexture::CMask::serial(), NLPACS::CGlobalRetriever::serial(), NLPACS::CFaceGrid::serial(), NLPACS::CExteriorMesh::serial(), NLPACS::CEdgeQuad::serial(), NLPACS::CCollisionMeshBuild::serial(), NL3D::CCluster::serial(), NLPACS::CChain::serial(), NLPACS::COrderedChain::serial(), NLPACS::COrderedChain3f::serial(), NLMISC::CBitSet::serial(), CAutomataDesc::CState::serial(), NL3D::CAnimationSet::serial(), NL3D::CAnimation::serial(), NL3D::CMaterialBase::serial(), and NLMISC::ICommand::serialCommands(). {serialVector(cont);}

void NLMISC::CStringStream::serialCont (  std::vector< bool > &  cont  )  [virtual]

Specialisation of serialCont() for vector<bool>. Reimplemented from NLMISC::CMemStream. Definition at line 340 of file string_stream.cpp. References NLMISC::contReset(), NLMISC::IStream::isReading(), len, serial(), sint, sint32, and v. { sint32 len=0; if(isReading()) { serial(len); // special version for vector: adjut good size. contReset(cont); cont.reserve(len); for(sint i=0;i<len;i++) { bool v; serial(v); cont.insert(cont.end(), v); } } else { len= cont.size(); serial(len); std::vector<bool>::iterator it= cont.begin(); for(sint i=0;i<len;i++, it++) { bool b = *it; serial( b ); } } }

virtual void NLMISC::CStringStream::serialCont (  std::vector< sint8 > &  cont  )  [inline, virtual]

Specialisation of serialCont() for vector<sint8>. Reimplemented from NLMISC::CMemStream. Definition at line 126 of file string_stream.h. References NLMISC::IStream::serialVector(). { serialVector(cont); }

virtual void NLMISC::CStringStream::serialCont (  std::vector< uint8 > &  cont  )  [inline, virtual]

Specialisation of serialCont() for vector<uint8>. Reimplemented from NLMISC::CMemStream. Definition at line 124 of file string_stream.h. References NLMISC::IStream::serialVector(). { serialVector(cont); }

template<class K, class T> void NLMISC::CStringStream::serialCont (  std::multimap< K, T > &  cont  )  [inline]

Specialisation of serialCont() for vector<bool>. Reimplemented from NLMISC::CMemStream. Definition at line 82 of file string_stream.h. {CMemStream::serialCont(cont);}

template<class K, class T> void NLMISC::CStringStream::serialCont (  std::map< K, T > &  cont  )  [inline]

Specialisation of serialCont() for vector<bool>. Reimplemented from NLMISC::CMemStream. Definition at line 80 of file string_stream.h. {CMemStream::serialCont(cont);}

template<class T> void NLMISC::CStringStream::serialCont (  std::multiset< T > &  cont  )  [inline]

Specialisation of serialCont() for vector<bool>. Reimplemented from NLMISC::CMemStream. Definition at line 78 of file string_stream.h. {CMemStream::serialCont(cont);}

template<class T> void NLMISC::CStringStream::serialCont (  std::set< T > &  cont  )  [inline]

Specialisation of serialCont() for vector<bool>. Reimplemented from NLMISC::CMemStream. Definition at line 76 of file string_stream.h. {CMemStream::serialCont(cont);}

template<class T> void NLMISC::CStringStream::serialCont (  std::deque< T > &  cont  )  [inline]

Specialisation of serialCont() for vector<bool>. Reimplemented from NLMISC::CMemStream. Definition at line 74 of file string_stream.h. {CMemStream::serialCont(cont);}

template<class T> void NLMISC::CStringStream::serialCont (  std::list< T > &  cont  )  [inline]

Specialisation of serialCont() for vector<bool>. Reimplemented from NLMISC::CMemStream. Definition at line 72 of file string_stream.h. {CMemStream::serialCont(cont);}

template<class T> void NLMISC::CStringStream::serialCont (  std::vector< T > &  cont  )  [inline]

Reimplemented from NLMISC::CMemStream. Definition at line 70 of file string_stream.h. {CMemStream::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(). {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(). {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(). {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(). {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(). {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(). {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(). {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(). {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(). {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(). {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(). { sint32 i; if(isReading()) { serial(i); em = (T)i; } else { i = em; serial(i); } }

void NLMISC::CStringStream::serialHex (  uint32 &  b  )  [virtual]

Serialisation in hexadecimal. Reimplemented from NLMISC::CMemStream. Definition at line 375 of file string_stream.cpp. References NLMISC::atoihex(), NLMISC::IStream::isReading(), readnumber, uint32, and writenumber. { if ( isReading() ) { readnumber( b, uint32, 10, atoihex ); // 4294967295 } else { writenumber( b, "%x", 10 ); } }

void NLMISC::IStream::serialMemStream (  CMemStream &  b  )  [virtual, inherited]

Serial memstream, bitmemstream... Definition at line 436 of file stream.cpp. References NLMISC::CMemStream::buffer(), NLMISC::CMemStream::bufferToFill(), NLMISC::IStream::isReading(), len, NLMISC::CMemStream::length(), NLMISC::CMemStream::resetBufPos(), NLMISC::IStream::serial(), NLMISC::IStream::serialBuffer(), uint32, and uint8. { uint32 len=0; // Serialize length if ( isReading() ) { // fill b with data from this serial (len); serialBuffer (b.bufferToFill (len), len); b.resetBufPos (); } else { // fill this with data from b len = b.length(); serial( len ); serialBuffer( (uint8*) b.buffer (), len ); } }

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(). { 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(). { uint64 node; // Open the node header xmlPushBegin ("PTR"); xmlSetAttrib ("id"); if(isReading()) { serial(node); // Close the header xmlPushEnd (); if(node==0) ptr=NULL; else { ItIdMap it; it= _IdMap.find(node); // Test if object already created/read. if( it==_IdMap.end() ) { // Construct object. ptr= new T; if(ptr==NULL) throw EStream(); // Insert the node. _IdMap.insert( ValueIdMap(node, ptr) ); // Read the object! serial(*ptr); } else ptr= static_cast<T*>(it->second); } } else { if(ptr==NULL) { node= 0; serial(node); // Close the header xmlPushEnd (); } else { ItIdMap it; it = _IdMap.find((uint64)(uint)ptr); // Test if object has been already written if( it==_IdMap.end() ) { // Not yet written // Get the next available ID node = _NextSerialPtrId++; // Serial the id serial(node); // Insert the pointer in the map with the id _IdMap.insert( ValueIdMap((uint64)(uint)ptr, (void*)(uint)node) ); // Close the header xmlPushEnd (); // Write the object serial(*ptr); } else { // Write only the object id node = (uint64)(uint)(it->second); serial(node); // Close the header xmlPushEnd (); } } } // Close the node xmlPop (); }

uint NLMISC::CStringStream::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 from NLMISC::CMemStream. Definition at line 41 of file string_stream.cpp. References NLMISC::IStream::isReading(), len, NLMISC::CMemStream::length(), NLMISC::CMemStream::lengthS(), nlassert, NLMISC::SEP_SIZE, NLMISC::SEPARATOR, NLMISC::CObjectVector< uint8, false >::size(), uint, uint32, and uint8. { nlassert( isReading() ); // Check that we don't read more than there is to read if ( ( _BufPos == _Buffer.end() ) || // we are at the end ( lengthS()+len+SEP_SIZE > length() ) && (_Buffer[_Buffer.size()-1] != SEPARATOR ) ) // we are before the end // calls virtual length (cf. sub messages) { throw EStreamOverflow(); } // Serialize in uint32 i = 0; while ( (i<len) && (*_BufPos) != SEPARATOR ) { *(buf+i) = *_BufPos; i++; _BufPos++; } // Exceeds len if ( (*_BufPos) != SEPARATOR ) { throw EStreamOverflow(); } _BufPos += SEP_SIZE; return i; }

void NLMISC::CStringStream::serialSeparatedBufferOut (  uint8 *  buf, uint  len )

Output: writes len bytes from buf into the stream. Reimplemented from NLMISC::CMemStream. Definition at line 71 of file string_stream.cpp. References NLMISC::IStream::isReading(), len, nlassert, NLMISC::CObjectVector< uint8, false >::resize(), NLMISC::SEP_SIZE, NLMISC::SEPARATOR, NLMISC::CObjectVector< uint8, false >::size(), uint, and uint8. { nlassert( ! isReading() ); // Serialize out _Buffer.resize( _Buffer.size() + len + SEP_SIZE ); _BufPos = _Buffer.end() - len - SEP_SIZE; memcpy( &(*_BufPos), buf, len ); _Buffer[_Buffer.size()-1] = SEPARATOR; _BufPos = _Buffer.end(); }

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 serialCont(), NLMISC::IStream::serialCont(), and NLMISC::CBitMemStream::serialCont(). { typedef typename T::value_type __value_type; typedef typename T::iterator __iterator; // Open a node header xmlPushBegin ("VECTOR"); // Attrib size xmlSetAttrib ("size"); sint32 len=0; if(isReading()) { serial(len); // Open a node header xmlPushEnd (); // special version for vector: adjut good size. contReset(cont); cont.resize (len); // Read the vector for(sint i=0;i<len;i++) { xmlPush ("ELM"); serial(cont[i]); xmlPop (); } } else { len= cont.size(); serial(len); // Close the node header xmlPushEnd (); // Write the vector __iterator it= cont.begin(); for(sint i=0;i<len;i++, it++) { xmlPush ("ELM"); serial(const_cast<__value_type&>(*it)); xmlPop (); } } // Close the node xmlPop (); }

uint NLMISC::IStream::serialVersion (  uint  currentVersion  )  [inherited]

Serialize a version number. Each object should store/read first a version number, using this method. Then he can use the streamVersion returned to see how he should serialise himself. NB: Version Number is read/store as a uint8, or uint32 if too bigger.. Parameters: currentVersion  the current version of the class, provided by user. Returns: the version of the stream. If the stream is an Output stream, currentVersion is returned. See also: setVersionException() getVersionException() Definition at line 266 of file stream.cpp. References NLMISC::IStream::_ThrowOnNewer, NLMISC::IStream::_ThrowOnOlder, NLMISC::IStream::isReading(), NLMISC::IStream::serial(), uint, uint32, uint8, v, NLMISC::IStream::xmlPop(), and NLMISC::IStream::xmlPush(). Referenced by NL3D::H_AUTO_DECL(), NLMISC::CEntityIdTranslator::load(), loadForm(), NLMISC::CEntityIdTranslator::save(), NLLIGO::CZoneRegion::serial(), NLLIGO::CZoneRegion::SZoneUnit2::serial(), NLLIGO::CZoneBankElement::serial(), NL3D::CZone::serial(), NL3D::CPatchInfo::CBindInfo::serial(), NL3D::CZone::CPatchConnect::serial(), NL3D::CBorderVertex::serial(), NL3D::CVertexBuffer::serial(), NL3D::CVegetableShape::serial(), NL3D::CVegetable::serial(), NL3D::CTrackSampledVector::serial(), NL3D::CTrackSampledQuat::serial(), NL3D::CTrackSampledCommon::CTimeBlock::serial(), NL3D::CTileVegetableDesc::serial(), NL3D::CTileNoiseMap::serial(), NL3D::CTileNoise::serial(), NLPACS::CSurfaceQuadTree::serial(), NL3D::CSurfaceLightGrid::CCellCorner::serial(), NL3D::CSurfaceLightGrid::serial(), NL3D::CSkeletonWeight::CNode::serial(), NL3D::CSkeletonWeight::serial(), NL3D::CInstanceGroup::serial(), NL3D::CInstanceGroup::CInstance::serial(), NLPACS::CRetrieverInstance::serial(), NLPACS::CRetrieverBank::serial(), NLPACS::CRetrievableSurface::serial(), NL3D::CPSAttrib< T >::serial(), NL3D::CPrimitiveBlock::serial(), NL3D::CPortal::serial(), NL3D::CPointLightNamedArray::CPointLightGroup::serial(), NL3D::CPointLightNamedArray::serial(), NL3D::CPointLightNamed::serial(), NL3D::CPointLight::serial(), NL3D::CPatch::serial(), NLMISC::CNoiseColorGradient::serial(), NLMISC::CNoiseValue::serial(), NL3D::CMeshMRMSkinnedGeom::CRdrPass::serial(), NL3D::CMeshMRMSkinnedGeom::CShadowVertex::serial(), NL3D::CMeshMRMSkinnedGeom::CPackedVertexBuffer::CPackedVertex::serial(), NL3D::CMeshMRMSkinnedGeom::CPackedVertexBuffer::serial(), NL3D::CMeshMRMSkinned::serial(), NL3D::CMeshMRMSkinnedGeom::serial(), NL3D::CMeshMRMGeom::CLodInfo::serial(), NL3D::CMeshMRMGeom::CRdrPass::serial(), NL3D::CMeshMRMGeom::CShadowVertex::serial(), NL3D::CMeshBase::CLightMapInfoList::serial(), NL3D::CMeshBase::CLightMapInfoList::CMatStage::serial(), NL3D::CMeshGeom::CMatrixBlock::serial(), NL3D::CMeshGeom::CRdrPass::serial(), NLMISC::CMatrix::serial(), NL3D::CMaterial::serial(), NL3D::CLodCharacterTexture::serial(), NL3D::CLodCharacterShapeBank::serial(), NL3D::CLodCharacterShape::serial(), NL3D::CLodCharacterShape::CBoneInfluence::serial(), NL3D::CLodCharacterShape::CAnim::serial(), NL3D::CLodCharacterShapeBuild::serial(), NLPACS::CLocalRetriever::serial(), NL3D::CIGSurfaceLight::CRetrieverLightGrid::serial(), NL3D::CIGSurfaceLight::serial(), NL3D::CHLSTextureBank::CTextureInstance::serial(), NL3D::CHLSTextureBank::serial(), NL3D::CHLSColorTexture::serial(), NL3D::CHLSColorTexture::CMask::serial(), NL3D::CHLSColorDelta::serial(), NLPACS::CGlobalRetriever::serial(), NLPACS::CFaceGrid::serial(), NLPACS::CExteriorMesh::serial(), NLPACS::CEdgeQuad::serial(), NL3D::CCluster::serial(), NLPACS::CChainQuad::serial(), NLPACS::CChain::serial(), NLPACS::COrderedChain::serial(), NLPACS::COrderedChain3f::serial(), NL3D::CBoneBase::serial(), NLMISC::CBitSet::serial(), NL3D::CAnimationSet::serial(), NL3D::CAnimationPlaylist::serial(), NL3D::CAnimation::serial(), NL3D::CMaterialBase::CTexAnimTracks::serial(), NL3D::CMaterialBase::serial(), NLMISC::CAABBox::serial(), NL3D::CMaterial::CLightMap::serial2(), NL3D::CTrackSampledCommon::serialCommon(), NL3D::CVertexBuffer::serialHeader(), NL3D::CMeshMRMGeom::serialLodVertexData(), and NL3D::CVertexBuffer::serialSubset(). { uint8 b=0; uint32 v=0; uint streamVersion; // Open the node xmlPush ("VERSION"); if(isReading()) { serial(b); if(b==0xFF) serial(v); else v=b; streamVersion=v; // Exception test. if(_ThrowOnOlder && streamVersion < currentVersion) throw EOlderStream(*this); if(_ThrowOnNewer && streamVersion > currentVersion) throw ENewerStream(*this); } else { v= streamVersion=currentVersion; if(v>=0xFF) { b=0xFF; serial(b); serial(v); } else { b= (uint8)v; serial(b); } } // Close the node xmlPop (); return streamVersion; }

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 NLMISC::CMemStream::invert(). { _InputStream= inputStream; }

void NLMISC::CMemStream::setStringMode (  bool  stringmode  )  [inline, inherited]

Set string mode. Definition at line 113 of file mem_stream.h. References NLMISC::CMemStream::_StringMode. Referenced by NLNET::CMessage::init(). { _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. { _ThrowOnOlder=throwOnOlder; _ThrowOnNewer=throwOnNewer; }

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(). { _XML = on; }

uint32 NLMISC::CMemStream::size (   )  const [inline, inherited]

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 NLMISC::CMemStream::lengthR(). { return _Buffer.size(); }

bool NLMISC::CMemStream::stringMode (   )  const [inline, inherited]

Return string mode. Definition at line 116 of file mem_stream.h. References NLMISC::CMemStream::_StringMode. Referenced by NLNET::TMessageRecord::serial(), and NLNET::CInetAddress::serial(). { 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(). { // XML Mode ? if (_XML) { return xmlBreakLineInternal (); } // Return ok return true; }

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(). { 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(). { // XML Mode ? if (_XML) { return xmlCommentInternal (comment); } // Return ok return true; }

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(). { return true; };

bool NLMISC::IStream::xmlPop (   )  [inline, inherited]

xmlPop() close the node. Returns: true if you can close the node, false if the node can't be closed (its header is still opened) or if there is no node to close. Definition at line 759 of file stream.h. References NLMISC::IStream::_XML, and NLMISC::IStream::xmlPopInternal(). 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::serialIStreamable(), NLMISC::IStream::serialMap(), NLMISC::IStream::serialMultimap(), NLMISC::IStream::serialPtr(), NLMISC::IStream::serialSTLCont(), NLMISC::IStream::serialSTLContLen(), NLMISC::IStream::serialSTLContPtr(), NLMISC::IStream::serialVector(), NLMISC::IStream::serialVectorPolyPtr(), NLMISC::IStream::serialVectorPtr(), NLMISC::IStream::serialVersion(), and NLMISC::IStream::xmlSerial(). { // XML Mode ? if (_XML) { return xmlPopInternal (); } // Return ok 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(). { 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(). { // XML Mode ? if (_XML) { // Open the header bool res=xmlPushBeginInternal (name); if (res) // close the header xmlPushEndInternal (); // Return the result return res; } // Return ok return true; }

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(). { // XML Mode ? if (_XML) { return xmlPushBeginInternal (name); } // Return ok return true; }

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(). { 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(). { // XML Mode ? if (_XML) { return xmlPushEndInternal (); } // Return ok return true; }

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(). { 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(). { // Open the node xmlPush (nodeName); // Serial the values serial (value0, value1, value2, value3); // Close the node xmlPop (); }

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(). { // Open the node xmlPush (nodeName); // Serial the values serial (value0, value1, value2); // Close the node xmlPop (); }

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(). { // Open the node xmlPush (nodeName); // Serial the values serial (value0, value1); // Close the node xmlPop (); }

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(). { // Open the node xmlPush (nodeName); // Serial the value serial (value0); // Close the node xmlPop (); }

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(). { // XML Mode ? if (_XML) { return xmlSetAttribInternal (name); } // Return ok return true; }

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(). { return true; };

---

Field Documentation

CObjectVector<uint8, false> NLMISC::CMemStream::_Buffer [protected, inherited]

Definition at line 516 of file mem_stream.h. Referenced by NLMISC::CMemStream::operator=().

uint8* NLMISC::CMemStream::_BufPos [protected, inherited]

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

uint32 NLMISC::CMemStream::_DefaultCapacity [protected, inherited]

Definition at line 521 of file mem_stream.h. Referenced by NLMISC::CMemStream::clear(), NLMISC::CMemStream::CMemStream(), and NLMISC::CMemStream::operator=().

bool NLMISC::CMemStream::_StringMode [protected, inherited]

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

---

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

• string_stream.h
• string_stream.cpp

---