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

NLMISC::CStringStream Class Reference

#include <string_stream.h> +

+

Inheritance diagram for NLMISC::CStringStream: +

+ +NLMISC::CMemStream +NLMISC::IStream + +

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 uint8buffer () const
uint8bufferToFill (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
CStringStreamoperator= (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. +

+

00549 { 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. +

+

00048 : CMemStream( inputStream, defaultcapacity ) {}
+
+

+ + + + +
+ + + + + + + + + + +
NLMISC::CStringStream::CStringStream const CStringStream other  )  [inline]
+
+ + + + + +
+   + + +

+Copy constructor. +

+ +

+Definition at line 51 of file string_stream.h. +

+

00051 : 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(). +

+

00239         {
+00240                 return _Buffer.getPtr();
+00241 /*              if ( _Buffer.empty() )
+00242                 {
+00243                         return NULL;
+00244                 }
+00245                 else
+00246                 {
+00247                         return &(*_Buffer.begin());
+00248                 }*/
+00249         }
+
+

+ + + + +
+ + + + + + + + + + +
uint8* NLMISC::CMemStream::bufferToFill uint32  msgsize  )  [inline, 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(). +

+

00307         {
+00308 #ifdef NL_DEBUG
+00309                 nlassert( isReading() );
+00310 #endif
+00311                 if ( msgsize == 0 )
+00312                         return NULL;
+00313 
+00314                 _Buffer.resize( msgsize );
+00315                 _BufPos = _Buffer.getPtr();
+00316                 /*if ( ! isReading() )
+00317                         _BufPos += msgsize;*/
+00318                 return _Buffer.getPtr();
+00319         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NLMISC::CMemStream::clear void   )  [inline, virtual, 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(). +

+

00202         {
+00203                 resetPtrTable();
+00204                 _Buffer.clear();
+00205                 if (!isReading())
+00206                 {
+00207                         _Buffer.resize (_DefaultCapacity);
+00208                 }
+00209                 _BufPos = _Buffer.getPtr();
+00210         }
+
+

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

+ +

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

+References NLMISC::CMemStream::_BufPos, NLMISC::CMemStream::length(), NLMISC::CMemStream::lengthS(), and value. +

+

00405         {
+00406                 //nldebug( "MEMSTREAM: Reading %u-byte value in %p at pos %u", sizeof(value), this, _BufPos - _Buffer.getPtr() );
+00407                 // Check that we don't read more than there is to read
+00408                 if ( lengthS()+sizeof(value) > length() ) // calls virtual length (cf. sub messages)
+00409                 {
+00410                         throw EStreamOverflow();
+00411                 }
+00412                 // Serialize in
+00413                 value = *(T*)_BufPos;
+00414                 _BufPos += sizeof(value);
+00415         }
+
+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::CMemStream::fastSerial T &  val  )  [inline, 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(). +

+

00372         {
+00373 #ifdef NL_LITTLE_ENDIAN
+00374                 if(isReading())
+00375                 {
+00376                         // Check that we don't read more than there is to read
+00377                         // TODO OPTIM we can remove the check if we want to be faster (50ms->43ms for 1 million serial)
+00378                         if ( lengthS()+sizeof(T) > length() ) // calls virtual length (cf. sub messages)
+00379                                 throw EStreamOverflow();
+00380                         // Serialize in
+00381                         val = *(T*)_BufPos;
+00382                 }
+00383                 else
+00384                 {
+00385                         increaseBufferIfNecessary (sizeof(T));
+00386                         *(T*)_BufPos = val;
+00387                 }
+00388                 _BufPos += sizeof (T);
+00389 #else // NL_LITTLE_ENDIAN
+00390                 IStream::serial( val );
+00391 #endif // NL_LITTLE_ENDIAN
+00392         }
+
+

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

+ +

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

+References NLMISC::CMemStream::_BufPos, NLMISC::CMemStream::increaseBufferIfNecessary(), and value. +

+

00396         {
+00397                 //nldebug( "MEMSTREAM: Writing %u-byte value in %p at pos %u", sizeof(value), this, _BufPos - _Buffer.getPtr() );
+00398                 increaseBufferIfNecessary (sizeof(T));
+00399                 *(T*)_BufPos = value;
+00400                 _BufPos += sizeof (T);
+00401         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::CMemStream::fill const uint8 srcbuf,
uint32  len
[inline, 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(). +

+

00278         {
+00279                 if (len == 0) return;
+00280 
+00281                 _Buffer.resize( len );
+00282                 CFastMem::memcpy( _Buffer.getPtr(), srcbuf, len );
+00283                 if (isReading())
+00284                 {
+00285                         _BufPos = _Buffer.getPtr();
+00286                 }
+00287                 else
+00288                 {
+00289                         _BufPos = _Buffer.getPtr() + _Buffer.size();
+00290                 }
+00291         }
+
+

+ + + + +
+ + + + + + + + + + +
sint32 NLMISC::CMemStream::getPos void   )  const [inline, 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. +

+

00160         {
+00161                 return _BufPos - _Buffer.getPtr();
+00162         }
+
+

+ + + + +
+ + + + + + + + + + +
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(). +

+

00154         {
+00155                 return _BufPos - _Buffer.getPtr();
+00156         }
+
+

+ + + + +
+ + + + + + + + + +
string NLMISC::IStream::getStreamName  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+Get a name for this stream. maybe a fileName if FileStream. Default is to return "". +

+Reimplemented in NLMISC::CIFile, and NLMISC::COFile. +

+Definition at line 420 of file stream.cpp. +

+Referenced by NLMISC::EStream::EStream(). +

+

00421 {
+00422         return "";
+00423 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::IStream::getVersionException bool &  throwOnOlder,
bool &  throwOnNewer
[static, inherited]
+
+ + + + + +
+   + + +

+Get the behavior of IStream regarding input stream that are older/newer than the class.

See also:
serialVersion() setVersionException()
+ +

+Definition at line 78 of file stream.cpp. +

+References NLMISC::IStream::_ThrowOnNewer, and NLMISC::IStream::_ThrowOnOlder. +

+

00079 {
+00080         throwOnOlder=_ThrowOnOlder;
+00081         throwOnNewer=_ThrowOnNewer;
+00082 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLMISC::CMemStream::increaseBufferIfNecessary uint32  len  )  [inline, 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(). +

+

00359         {
+00360                 uint32 oldBufferSize = _Buffer.size();
+00361                 if (_BufPos - _Buffer.getPtr() + len > oldBufferSize)
+00362                 {
+00363                         // need to increase the buffer size
+00364                         uint32 pos = _BufPos - _Buffer.getPtr();
+00365                         _Buffer.resize(oldBufferSize*2 + len);
+00366                         _BufPos = _Buffer.getPtr() + pos;
+00367                 }
+00368         }
+
+

+ + + + +
+ + + + + + + + + +
virtual void NLMISC::CMemStream::invert  )  [inline, virtual, 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(). +

+

00332         {
+00333                 if ( isReading() )
+00334                 {
+00335                         // In->Out: We want to write (serialize out) what we have read (serialized in)
+00336                         uint32 sizeOfReadStream = lengthR();
+00337                         resetPtrTable();
+00338                         setInOut( false );
+00339                         _BufPos = _Buffer.getPtr() + sizeOfReadStream;
+00340                 }
+00341                 else
+00342                 {
+00343                         // Out->In: We want to read (serialize in) what we have written (serialized out)
+00344                         resetPtrTable();
+00345                         setInOut( true );
+00346                         _Buffer.resize (_BufPos - _Buffer.getPtr());
+00347                         _BufPos = _Buffer.getPtr();
+00348                 }
+00349         }
+
+

+ + + + +
+ + + + + + + + + +
bool NLMISC::IStream::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(). +

+

00065 {
+00066         return _InputStream;
+00067 }
+
+

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

+ +

+Definition at line 221 of file stream.h. +

+References NLMISC::IStream::_XML. +

+Referenced by NLMISC::CMemStream::serial(). +

+

00221 { 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(). +

+

00218         {
+00219                 if ( isReading() )
+00220                 {
+00221                         return lengthR();
+00222                 }
+00223                 else
+00224                 {
+00225                         return lengthS();
+00226                 }
+00227         }
+
+

+ + + + +
+ + + + + + + + + +
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(). +

+

00512         {
+00513                 return size();
+00514         }
+
+

+ + + + +
+ + + + + + + + + +
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(). +

+

00503         {
+00504                 return _BufPos - _Buffer.getPtr(); // not calling getPos() because virtual and not const!
+00505         }
+
+

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

+Assignment operator. +

+ +

+Definition at line 54 of file string_stream.h. +

+

00054 { CMemStream::operator=( other ); return *this; }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NLMISC::CMemStream::poke 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. +

+

00191         {
+00192                 if ( ! isReading() )
+00193                 {
+00194                         uint8 *pokeBufPos = _Buffer.getPtr() + pos;
+00195                         nlassert( pokeBufPos + sizeof(T) <= _BufPos );
+00196                         *(T*)pokeBufPos = value;
+00197                 }
+00198         }
+
+

+ + + + +
+ + + + + + + + + + +
sint32 NLMISC::CMemStream::reserve uint  len  )  [inline, 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. +

+

00169         {
+00170                 sint32 pos = _BufPos - _Buffer.getPtr();
+00171                 if ( ! isReading() )
+00172                 {
+00173                         increaseBufferIfNecessary( len );
+00174                         _BufPos += len;
+00175                 }
+00176                 return pos;
+00177         }
+
+

+ + + + +
+ + + + + + + + + +
void NLMISC::CMemStream::resetBufPos  )  [inline, 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(). +

+

00270 { _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(). +

+

00352 { 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. +

+

00236 {
+00237         if (size == length()) return;
+00238         // need to increase the buffer size
+00239         uint32 pos = _BufPos - _Buffer.getPtr();
+00240         _Buffer.resize(size);
+00241         _BufPos = _Buffer.getPtr() + pos;
+00242 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLMISC::CMemStream::seek sint32  offset,
TSeekOrigin  origin
throw (EStream) [virtual, 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(). +

+

00178 {
+00179         switch (origin)
+00180         {
+00181         case begin:
+00182                 if (offset > (sint)length())
+00183                         return false;
+00184                 if (offset < 0)
+00185                         return false;
+00186                 _BufPos=_Buffer.getPtr()+offset;
+00187                 break;
+00188         case current:
+00189                 if (getPos ()+offset > (sint)length())
+00190                         return false;
+00191                 if (getPos ()+offset < 0)
+00192                         return false;
+00193                 _BufPos+=offset;
+00194                 break;
+00195         case end:
+00196                 if (offset < -(sint)length())
+00197                         return false;
+00198                 if (offset > 0)
+00199                         return false;
+00200                 _BufPos=_Buffer.getPtr()+_Buffer.size()+offset;
+00201                 break;
+00202         }
+00203         return true;
+00204 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLMISC::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. +

+

00317 {
+00318         sint32  len=0;
+00319         // Read/Write the length.
+00320         if(isReading())
+00321         {
+00322                 serial(len);
+00323                 b.resize(len);
+00324         }
+00325         else
+00326         {
+00327                 len= b.size();
+00328                 serial(len);
+00329         }
+00330         // Read/Write the string.
+00331         for(sint i=0;i<len;i++)
+00332                 serialBuffer( (uint8*)&b[i], sizeof( sizeof(b[i]) ) );
+00333 
+00334         char sep = SEPARATOR;
+00335         serialBuffer( (uint8*)&sep, 1 );
+00336 }
+
+

+ + + + +
+ + + + + + + + + + +
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. +

+

00291 {
+00292         sint32  len=0;
+00293         // Read/Write the length.
+00294         if(isReading())
+00295         {
+00296                 serial(len);
+00297                 nlassert( len<1000000 ); // limiting string size
+00298                 b.resize(len);
+00299         }
+00300         else
+00301         {
+00302                 len= b.size();
+00303                 serial(len);
+00304         }
+00305         
+00306         // Read/Write the string.
+00307         for(sint i=0;i<len;i++)
+00308                 serialBuffer( (uint8*)&(b[i]), sizeof(b[i]) );
+00309 
+00310         char sep = SEPARATOR;
+00311         serialBuffer( (uint8*)&sep, 1 );
+00312 }
+
+

+ + + + +
+ + + + + + + + + + +
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. +

+

00272 {
+00273         char buff [2];
+00274         if ( isReading() )
+00275         {
+00276                 serialBuffer( (uint8*)buff, 2 );
+00277                 b = buff[0];
+00278         }
+00279         else
+00280         {
+00281                 buff[0] = b;
+00282                 buff[1] = SEPARATOR;
+00283                 serialBuffer( (uint8*)buff, 2 );
+00284         }
+00285 
+00286 }
+
+

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

+ +

+Reimplemented from NLMISC::CMemStream. +

+Definition at line 246 of file string_stream.cpp. +

+References serialBit(). +

+

00247 {
+00248         serialBit(b);
+00249 }
+
+

+ + + + +
+ + + + + + + + + + +
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. +

+

00234 {
+00235         if ( isReading() )
+00236         {
+00237                 readnumber( b, double, 128, atof ); //
+00238         }
+00239         else
+00240         {
+00241                 writenumber( b, "%f", 128 );
+00242         }
+00243 }
+
+

+ + + + +
+ + + + + + + + + + +
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. +

+

00221 {
+00222         if ( isReading() )
+00223         {
+00224                 readnumber( b, float, 128, atof ); // ?
+00225         }
+00226         else
+00227         {
+00228                 writenumber( (double)b, "%f", 128 );
+00229         }
+00230 }
+
+

+ + + + +
+ + + + + + + + + + +
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. +

+

00208 {
+00209         if ( isReading() )
+00210         {
+00211                 readnumber( b, sint64, 20, atoiInt64 ); // -9223372036854775808
+00212         }
+00213         else
+00214         {
+00215                 writenumber( b, "%"NL_I64"d", 20 );
+00216         }
+00217 }
+
+

+ + + + +
+ + + + + + + + + + +
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. +

+

00195 {
+00196         if ( isReading() )
+00197         {
+00198                 readnumber( b, uint64, 20, atoiInt64 ); // 18446744073709551615
+00199         }
+00200         else
+00201         {
+00202                 writenumber( b, "%"NL_I64"u", 20 );
+00203         }
+00204 }
+
+

+ + + + +
+ + + + + + + + + + +
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. +

+

00182 {
+00183         if ( isReading() )
+00184         {
+00185                 readnumber( b, sint32, 11, atoi ); // -2147483648
+00186         }
+00187         else
+00188         {
+00189                 writenumber( b, "%d", 11 );
+00190         }
+00191 }
+
+

+ + + + +
+ + + + + + + + + + +
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. +

+

00169 {
+00170         if ( isReading() )
+00171         {
+00172                 readnumber( b, uint32, 10, atoui ); // 4294967295
+00173         }
+00174         else
+00175         {
+00176                 writenumber( b, "%u", 10 );
+00177         }
+00178 }
+
+

+ + + + +
+ + + + + + + + + + +
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. +

+

00156 {
+00157         if ( isReading() )
+00158         {
+00159                 readnumber( b, sint16, 6, atoi ); // -32768
+00160         }
+00161         else
+00162         {
+00163                 writenumber( b, "%hd", 6 );
+00164         }
+00165 }
+
+

+ + + + +
+ + + + + + + + + + +
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. +

+

00142 {
+00143         // No byte swapping in text mode
+00144         if ( isReading() )
+00145         {
+00146                 readnumber( b, uint16, 5, atoi ); // 65535
+00147         }
+00148         else
+00149         {
+00150                 writenumber( b, "%hu", 5 );
+00151         }
+00152 }
+
+

+ + + + +
+ + + + + + + + + + +
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. +

+

00129 {
+00130         if ( isReading() )
+00131         {
+00132                 readnumber( b, sint8, 4, atoi ); // -128
+00133         }
+00134         else
+00135         {
+00136                 writenumber( (sint16)b, "%hd", 4 );
+00137         }
+00138 }
+
+

+ + + + +
+ + + + + + + + + + +
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. +

+

00116 {
+00117         if ( isReading() )
+00118         {
+00119                 readnumber( b, uint8, 3, atoi ); // 255
+00120         }
+00121         else
+00122         {
+00123                 writenumber( (uint16)b,"%hu", 3 );
+00124         }
+00125 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+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(). +

+

00098         { 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(). +

+

00095         { 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(). +

+

00092         { 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(). +

+

00089         { 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(). +

+

00086         { 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(). +

+

00067 { 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(). +

+

00254 {
+00255         uint8 u;
+00256         if ( isReading() )
+00257         {
+00258                 serial( u );
+00259                 bit = (u!=0);
+00260         }
+00261         else
+00262         {
+00263                 u = (uint8)bit;
+00264                 serial( u );
+00265         }
+00266 }
+
+

+ + + + +
+ + + + + + + + + + +
uint16 NLMISC::IStream::serialBitField16 uint16  bf  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Serialisation of bitfield <=16 bits. +

+ +

+Definition at line 332 of file stream_inline.h. +

+References NLMISC::IStream::serial(), and uint16. +

+

00333 {
+00334         serial(bf);
+00335         return bf;
+00336 }
+
+

+ + + + +
+ + + + + + + + + + +
uint32 NLMISC::IStream::serialBitField32 uint32  bf  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Serialisation of bitfield <=32 bits. +

+ +

+Definition at line 338 of file stream_inline.h. +

+References NLMISC::IStream::serial(), and uint32. +

+

00339 {
+00340         serial(bf);
+00341         return bf;
+00342 }
+
+

+ + + + +
+ + + + + + + + + + +
uint8 NLMISC::IStream::serialBitField8 uint8  bf  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Serialisation of bitfield <=8 bits. +

+ +

+Definition at line 326 of file stream_inline.h. +

+References NLMISC::IStream::serial(), and uint8. +

+Referenced by NL3D::CMaterial::CTexEnv::serial(). +

+

00327 {
+00328         serial(bf);
+00329         return bf;
+00330 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::CMemStream::serialBuffer uint8 buf,
uint  len
[virtual, 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(). +

+

00074 {
+00075         // commented for optimum performance
+00076         nlassert (len > 0);
+00077         nlassert (buf != NULL);
+00078 
+00079         if ( isReading() )
+00080         {
+00081                 // Check that we don't read more than there is to read
+00082                 if ( lengthS()+len > length() ) // calls virtual length (cf. sub messages)
+00083                 {
+00084                         throw EStreamOverflow();
+00085                 }
+00086                 // Serialize in
+00087                 CFastMem::memcpy( buf, _BufPos, len );
+00088                 _BufPos += len;
+00089         }
+00090         else
+00091         {
+00092                 // Serialize out
+00093 
+00094                 increaseBufferIfNecessary (len);
+00095 /*              uint32 oldBufferSize = _Buffer.size();
+00096                 if (_BufPos - _Buffer.getPtr() + len > oldBufferSize)
+00097                 {
+00098                         // need to increase the buffer size
+00099                         uint32 pos = _BufPos - _Buffer.getPtr();
+00100                         _Buffer.resize(oldBufferSize*2 + len);
+00101                         _BufPos = _Buffer.getPtr() + pos;
+00102                 }
+00103 */
+00104                 CFastMem::memcpy( _BufPos, buf, len );
+00105                 _BufPos += len;
+00106 
+00107 /*              _Buffer.resize( size );
+00108                 _BufPos = _Buffer.end() - len;
+00109                 CFastMem::memcpy( &(*_BufPos), buf, len );
+00110                 _BufPos = _Buffer.end();*/
+00111         }
+00112 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
virtual void NLMISC::IStream::serialBufferWithSize uint8 buf,
uint32  len
[inline, virtual, inherited]
+
+ + + + + +
+   + + +

+This method first serializes the size of the buffer and after the buffer itself, it enables the possibility to serial with a serialCont() on the other side. +

+Definition at line 877 of file stream.h. +

+References len, NLMISC::IStream::serial(), NLMISC::IStream::serialBuffer(), uint32, and uint8. +

+

00878         {
+00879                 serial (len);
+00880                 serialBuffer (buf, len);
+00881         }
+
+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialCheck const T &  value  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Serialize a check value. An object can stream a check value to check integrity or format of filed or streamed data. Just call serial check with a const value. Write will serial the value. Read will check the value is the same. If it is not, it will throw EInvalidDataStream exception.

+NB: The type of the value must implement an operator == and must be serializable.

Parameters:
+ + +
value the value used to the check.
+
+
See also:
EInvalidDataStream
+ +

+Definition at line 520 of file stream.h. +

+References NLMISC::IStream::isReading(), NLMISC::IStream::serial(), value, NLMISC::IStream::xmlPop(), and NLMISC::IStream::xmlPush(). +

+Referenced by NLNET::cbPacsAnswer(), NLNET::CPacsClient::initMessage(), loadForm(), NLLIGO::CZoneRegion::serial(), NLLIGO::CZoneBankElement::serial(), NL3D::CZone::serial(), NL3D::CVegetableShape::serial(), NL3D::CSkeletonWeight::serial(), NL3D::CInstanceGroup::serial(), NL3D::CLodCharacterShape::serial(), NL3D::CLodCharacterShapeBuild::serial(), NL3D::CAnimationSet::serial(), and NL3D::CAnimation::serial(). +

+

00521         {
+00522                 // Open a node
+00523                 xmlPush ("CHECK");
+00524 
+00525                 if (isReading()) 
+00526                 { 
+00527                         T read;
+00528                         serial (read); 
+00529                         if (read!=value) 
+00530                                 throw EInvalidDataStream(*this); 
+00531                 } 
+00532                 else 
+00533                 { 
+00534                         serial (const_cast<T&>(value)); 
+00535                 }
+00536 
+00537                 // Close the node 
+00538                 xmlPop ();
+00539         }
+
+

+ + + + +
+ + + + + + + + + + + + + +
+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(). +

+

00324 {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. +

+

00341 {
+00342         sint32  len=0;
+00343         if(isReading())
+00344         {
+00345                 serial(len);
+00346                 // special version for vector: adjut good size.
+00347                 contReset(cont);
+00348                 cont.reserve(len);
+00349 
+00350                 for(sint i=0;i<len;i++)
+00351                 {
+00352                         bool    v;
+00353                         serial(v);
+00354                         cont.insert(cont.end(), v);
+00355                 }
+00356         }
+00357         else
+00358         {
+00359                 len= cont.size();
+00360                 serial(len);
+00361 
+00362                 std::vector<bool>::iterator it= cont.begin();
+00363                 for(sint i=0;i<len;i++, it++)
+00364                 {
+00365                         bool b = *it;
+00366                         serial( b );
+00367                 }
+00368         }
+00369 }
+
+

+ + + + +
+ + + + + + + + + + +
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(). +

+

00126 { 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(). +

+

00124 { 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. +

+

00082 {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. +

+

00080 {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. +

+

00078 {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. +

+

00076 {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. +

+

00074 {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. +

+

00072 {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. +

+

00070 {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(). +

+

00379 {serialSTLContPolyPtr(cont);}
+
+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPolyPtr std::set< T > &  cont  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Serialize a check value. An object can stream a check value to check integrity or format of filed or streamed data. Just call serial check with a const value. Write will serial the value. Read will check the value is the same. If it is not, it will throw EInvalidDataStream exception.

+NB: The type of the value must implement an operator == and must be serializable.

Parameters:
+ + +
value the value used to the check.
+
+
See also:
EInvalidDataStream
+ +

+Definition at line 377 of file stream.h. +

+References NLMISC::IStream::serialSTLContPolyPtr(). +

+

00377 {serialSTLContPolyPtr(cont);}
+
+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPolyPtr std::deque< T > &  cont  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Serialize a check value. An object can stream a check value to check integrity or format of filed or streamed data. Just call serial check with a const value. Write will serial the value. Read will check the value is the same. If it is not, it will throw EInvalidDataStream exception.

+NB: The type of the value must implement an operator == and must be serializable.

Parameters:
+ + +
value the value used to the check.
+
+
See also:
EInvalidDataStream
+ +

+Definition at line 375 of file stream.h. +

+References NLMISC::IStream::serialSTLContPolyPtr(). +

+

00375 {serialSTLContPolyPtr(cont);}
+
+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPolyPtr std::list< T > &  cont  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Serialize a check value. An object can stream a check value to check integrity or format of filed or streamed data. Just call serial check with a const value. Write will serial the value. Read will check the value is the same. If it is not, it will throw EInvalidDataStream exception.

+NB: The type of the value must implement an operator == and must be serializable.

Parameters:
+ + +
value the value used to the check.
+
+
See also:
EInvalidDataStream
+ +

+Definition at line 373 of file stream.h. +

+References NLMISC::IStream::serialSTLContPolyPtr(). +

+

00373 {serialSTLContPolyPtr(cont);}
+
+

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

+Serialize a check value. An object can stream a check value to check integrity or format of filed or streamed data. Just call serial check with a const value. Write will serial the value. Read will check the value is the same. If it is not, it will throw EInvalidDataStream exception.

+NB: The type of the value must implement an operator == and must be serializable.

Parameters:
+ + +
value the value used to the check.
+
+
See also:
EInvalidDataStream
+ +

+Definition at line 371 of file stream.h. +

+References NLMISC::IStream::serialVectorPolyPtr(). +

+Referenced by NL3D::CAnimation::serial(). +

+

00371 {serialVectorPolyPtr(cont);}
+
+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPtr std::multiset< T > &  cont  )  [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 362 of file stream.h. +

+References NLMISC::IStream::serialSTLContPtr(). +

+

00362 {serialSTLContPtr(cont);}
+
+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPtr std::set< T > &  cont  )  [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 360 of file stream.h. +

+References NLMISC::IStream::serialSTLContPtr(). +

+

00360 {serialSTLContPtr(cont);}
+
+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPtr std::deque< T > &  cont  )  [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 358 of file stream.h. +

+References NLMISC::IStream::serialSTLContPtr(). +

+

00358 {serialSTLContPtr(cont);}
+
+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPtr std::list< T > &  cont  )  [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 356 of file stream.h. +

+References NLMISC::IStream::serialSTLContPtr(). +

+

00356 {serialSTLContPtr(cont);}
+
+

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

+ +

+Definition at line 354 of file stream.h. +

+References NLMISC::IStream::serialVectorPtr(). +

+Referenced by NL3D::CAnimationSet::serial(). +

+

00354 {serialVectorPtr(cont);}
+
+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialEnum T &  em  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Template enum serialisation. Serialized as a sint32. +

+ +

+Definition at line 261 of file stream.h. +

+References NLMISC::IStream::isReading(), NLMISC::IStream::serial(), and sint32. +

+Referenced by NLNET::cbTCReceiveOtherSideClass(), NL3D::CVegetableShape::serial(), NL3D::CVegetable::serial(), NLPACS::CRetrieverInstance::serial(), NL3D::CPointLight::serial(), NL3D::CMaterial::serial(), NLPACS::CLocalRetriever::serial(), NLMISC::CSerialCommand::serial(), and NL3D::CAnimationPlaylist::serial(). +

+

00262         {
+00263                 sint32  i;
+00264                 if(isReading())
+00265                 {
+00266                         serial(i);
+00267                         em = (T)i;
+00268                 }
+00269                 else
+00270                 {
+00271                         i = em;
+00272                         serial(i);
+00273                 }
+00274         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLMISC::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. +

+

00376 {
+00377         if ( isReading() )
+00378         {
+00379                 readnumber( b, uint32, 10, atoihex ); // 4294967295
+00380         }
+00381         else
+00382         {
+00383                 writenumber( b, "%x", 10 );
+00384         }
+00385 }
+
+

+ + + + +
+ + + + + + + + + + +
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. +

+

00437 {
+00438         uint32 len=0;
+00439 
+00440         // Serialize length
+00441         if ( isReading() )
+00442         {
+00443                 // fill b with data from this
+00444                 serial (len);
+00445                 serialBuffer (b.bufferToFill (len), len);
+00446                 b.resetBufPos ();
+00447         }
+00448         else
+00449         {
+00450                 // fill this with data from b
+00451                 len = b.length();
+00452 
+00453                 serial( len );
+00454                 serialBuffer( (uint8*) b.buffer (), len );
+00455         }
+00456 }
+
+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialPolyPtr T *&  ptr  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Serialize Polymorphic Objet Ptr. Works with NULL pointers. If the same object is found mutliple time in the stream, ONLY ONE instance is written! NB: The ptr is serialised as a uint64 (64 bit compliant).

Parameters:
+ + +
ptr a pointer on a IStreamable object.
+
+
See also:
resetPtrTable()
+ +

+Definition at line 492 of file stream.h. +

+References NLMISC::IStream::serialIStreamable(). +

+Referenced by NL3D::CAnimationOptimizer::cloneTrack(), NL3D::CMaterial::CLightMap::serial(), NL3D::CMaterial::serial(), NL3D::CMaterialBase::CAnimatedTexture::serial(), NL3D::CMaterial::CLightMap::serial2(), and NLMISC::IStream::serialSTLContLenPolyPtr(). +

+

00493         { IStreamable *p=ptr; serialIStreamable(p); ptr= static_cast<T*>(p);}
+
+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialPtr T *&  ptr  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Serialize Non Polymorphic Objet Ptr. Works with NULL pointers. If the same object is found mutliple time in the stream, ONLY ONE instance is written! NB: The ptr is serialised as a uint64 (64 bit compliant).

Parameters:
+ + +
ptr a pointer on a base type or an object.
+
+
See also:
resetPtrTable()
+ +

+Definition at line 390 of file stream.h. +

+References NLMISC::IStream::_IdMap, NLMISC::IStream::_NextSerialPtrId, NLMISC::IStream::isReading(), NLMISC::IStream::ItIdMap, NLMISC::IStream::serial(), uint, uint64, NLMISC::IStream::ValueIdMap, NLMISC::IStream::xmlPop(), NLMISC::IStream::xmlPushBegin(), NLMISC::IStream::xmlPushEnd(), and NLMISC::IStream::xmlSetAttrib(). +

+Referenced by NL3D::CParticleSystemShape::buildFromPS(), NL3D::CParticleSystemShape::flushTextures(), NL3D::CParticleSystemShape::instanciatePS(), and NLMISC::IStream::serialSTLContLenPtr(). +

+

00391         {
+00392                 uint64  node;
+00393 
+00394                 // Open the node header
+00395                 xmlPushBegin ("PTR");
+00396 
+00397                 xmlSetAttrib ("id");
+00398 
+00399                 if(isReading())
+00400                 {
+00401                         serial(node);
+00402 
+00403                         // Close the header
+00404                         xmlPushEnd ();
+00405 
+00406                         if(node==0)
+00407                                 ptr=NULL;
+00408                         else
+00409                         {
+00410                                 ItIdMap it;
+00411                                 it= _IdMap.find(node);
+00412 
+00413                                 // Test if object already created/read.
+00414                                 if( it==_IdMap.end() )
+00415                                 {
+00416                                         // Construct object.                                    
+00417                                         ptr= new T;
+00418                                         if(ptr==NULL)
+00419                                                 throw EStream();
+00420 
+00421                                         // Insert the node.
+00422                                         _IdMap.insert( ValueIdMap(node, ptr) );
+00423 
+00424                                         // Read the object!
+00425                                         serial(*ptr);
+00426                                 }
+00427                                 else
+00428                                         ptr= static_cast<T*>(it->second);
+00429                         }
+00430                 }
+00431                 else
+00432                 {
+00433                         if(ptr==NULL)
+00434                         {
+00435                                 node= 0;
+00436                                 serial(node);
+00437 
+00438                                 // Close the header
+00439                                 xmlPushEnd ();
+00440                         }
+00441                         else
+00442                         {
+00443                                 ItIdMap it;
+00444                                 it = _IdMap.find((uint64)(uint)ptr);
+00445 
+00446                                 // Test if object has been already written
+00447                                 if( it==_IdMap.end() )
+00448                                 {
+00449                                         // Not yet written
+00450 
+00451                                         // Get the next available ID
+00452                                         node = _NextSerialPtrId++;
+00453 
+00454                                         // Serial the id
+00455                                         serial(node);
+00456 
+00457                                         // Insert the pointer in the map with the id
+00458                                         _IdMap.insert( ValueIdMap((uint64)(uint)ptr, (void*)(uint)node) );
+00459 
+00460                                         // Close the header
+00461                                         xmlPushEnd ();
+00462 
+00463                                         // Write the object
+00464                                         serial(*ptr);
+00465                                 }
+00466                                 else
+00467                                 {
+00468                                         // Write only the object id
+00469                                         node = (uint64)(uint)(it->second);
+00470 
+00471                                         serial(node);
+00472                 
+00473                                         // Close the header
+00474                                         xmlPushEnd ();
+00475                                 }
+00476                         }
+00477                 }
+00478 
+00479                 // Close the node
+00480                 xmlPop ();
+00481         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
uint NLMISC::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. +

+

00042 {
+00043         nlassert( isReading() );
+00044 
+00045         // Check that we don't read more than there is to read
+00046         if ( ( _BufPos == _Buffer.end() ) || // we are at the end
+00047                  ( lengthS()+len+SEP_SIZE > length() ) && (_Buffer[_Buffer.size()-1] != SEPARATOR ) ) // we are before the end // calls virtual length (cf. sub messages)
+00048         {
+00049                 throw EStreamOverflow();
+00050         }
+00051         // Serialize in
+00052         uint32 i = 0;
+00053         while ( (i<len) && (*_BufPos) != SEPARATOR )
+00054         {
+00055                 *(buf+i) = *_BufPos;
+00056                 i++;
+00057                 _BufPos++;
+00058         }
+00059         // Exceeds len
+00060         if ( (*_BufPos) != SEPARATOR )
+00061         {
+00062                 throw EStreamOverflow();
+00063         }
+00064         _BufPos += SEP_SIZE;
+00065         return i;
+00066 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
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. +

+

00072 {
+00073         nlassert( ! isReading() );
+00074         
+00075         // Serialize out
+00076         _Buffer.resize( _Buffer.size() + len + SEP_SIZE );
+00077         _BufPos = _Buffer.end() - len - SEP_SIZE;
+00078         memcpy( &(*_BufPos), buf, len );
+00079         _Buffer[_Buffer.size()-1] = SEPARATOR;
+00080         _BufPos = _Buffer.end();
+00081 }
+
+

+ + + + +
+ + + + + + + + + + + + + +
+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(). +

+

00993         {
+00994                 typedef typename T::value_type __value_type;
+00995                 typedef typename T::iterator __iterator;
+00996 
+00997                 // Open a node header
+00998                 xmlPushBegin ("VECTOR");
+00999 
+01000                 // Attrib size
+01001                 xmlSetAttrib ("size");
+01002 
+01003                 sint32  len=0;
+01004                 if(isReading())
+01005                 {
+01006                         serial(len);
+01007 
+01008                         // Open a node header
+01009                         xmlPushEnd ();
+01010 
+01011                         // special version for vector: adjut good size.
+01012                         contReset(cont);
+01013                         cont.resize (len);
+01014 
+01015                         // Read the vector
+01016                         for(sint i=0;i<len;i++)
+01017                         {
+01018                                 xmlPush ("ELM");
+01019 
+01020                                 serial(cont[i]);
+01021 
+01022                                 xmlPop ();
+01023                         }
+01024                 }
+01025                 else
+01026                 {
+01027                         len= cont.size();
+01028                         serial(len);
+01029 
+01030                         // Close the node header
+01031                         xmlPushEnd ();
+01032 
+01033                         // Write the vector
+01034                         __iterator              it= cont.begin();
+01035                         for(sint i=0;i<len;i++, it++)
+01036                         {
+01037                                 xmlPush ("ELM");
+01038 
+01039                                 serial(const_cast<__value_type&>(*it));
+01040 
+01041                                 xmlPop ();
+01042                         }
+01043                 }
+01044 
+01045                 // Close the node
+01046                 xmlPop ();
+01047         }
+
+

+ + + + +
+ + + + + + + + + + +
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(). +

+

00267 {
+00268         uint8   b=0;
+00269         uint32  v=0;
+00270         uint    streamVersion;
+00271 
+00272         // Open the node
+00273         xmlPush ("VERSION");
+00274 
+00275         if(isReading())
+00276         {
+00277                 serial(b);
+00278                 if(b==0xFF)
+00279                         serial(v);
+00280                 else
+00281                         v=b;
+00282                 streamVersion=v;
+00283 
+00284                 // Exception test.
+00285                 if(_ThrowOnOlder && streamVersion < currentVersion)
+00286                         throw EOlderStream(*this);
+00287                 if(_ThrowOnNewer && streamVersion > currentVersion)
+00288                         throw ENewerStream(*this);
+00289         }
+00290         else
+00291         {
+00292                 v= streamVersion=currentVersion;
+00293                 if(v>=0xFF)
+00294                 {
+00295                         b=0xFF;
+00296                         serial(b);
+00297                         serial(v);
+00298                 }
+00299                 else
+00300                 {
+00301                         b= (uint8)v;
+00302                         serial(b);
+00303                 }
+00304         }
+00305 
+00306         // Close the node
+00307         xmlPop ();
+00308 
+00309         return streamVersion;
+00310 }
+
+

+ + + + +
+ + + + + + + + + + +
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(). +

+

00414 {
+00415         _InputStream= inputStream;
+00416 }
+
+

+ + + + +
+ + + + + + + + + + +
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(). +

+

00113 { _StringMode = stringmode; }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::IStream::setVersionException bool  throwOnOlder,
bool  throwOnNewer
[static, inherited]
+
+ + + + + +
+   + + +

+Set the behavior of IStream regarding input stream that are older/newer than the class. If throwOnOlder==true, IStream throws a EOlderStream when needed. If throwOnNewer==true, IStream throws a ENewerStream when needed.

+By default, the behavior is throwOnOlder=false, throwOnNewer=true.

See also:
serialVersion() getVersionException()
+ +

+Definition at line 71 of file stream.cpp. +

+References NLMISC::IStream::_ThrowOnNewer, and NLMISC::IStream::_ThrowOnOlder. +

+

00072 {
+00073         _ThrowOnOlder=throwOnOlder;
+00074         _ThrowOnNewer=throwOnNewer;
+00075 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::setXMLMode bool  on  )  [protected, inherited]
+
+ + + + + +
+   + + +

+Set the XML mode is true to enable XML mode else false +

+Definition at line 427 of file stream.cpp. +

+References NLMISC::IStream::_XML. +

+Referenced by NLMISC::COXml::COXml(), and NLMISC::COXml::init(). +

+

00428 {
+00429         _XML = on;
+00430 }
+
+

+ + + + +
+ + + + + + + + + +
uint32 NLMISC::CMemStream::size  )  const [inline, 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(). +

+

00231         {
+00232                 return _Buffer.size();
+00233         }
+
+

+ + + + +
+ + + + + + + + + +
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(). +

+

00116 { return _StringMode; }
+
+

+ + + + +
+ + + + + + + + + +
bool NLMISC::IStream::xmlBreakLine  )  [inline, inherited]
+
+ + + + + +
+   + + +

+xmlBreakLine() insert a break line in the XML stream.

+

Returns:
true if the break line is added, return false if no node is opened.
+ +

+Definition at line 794 of file stream.h. +

+References NLMISC::IStream::_XML, and NLMISC::IStream::xmlBreakLineInternal(). +

+

00795         {
+00796                 // XML Mode ?
+00797                 if (_XML)
+00798                 {
+00799                         return xmlBreakLineInternal ();
+00800                 }
+00801 
+00802                 // Return ok
+00803                 return true;
+00804         }
+
+

+ + + + +
+ + + + + + + + + +
virtual bool NLMISC::IStream::xmlBreakLineInternal  )  [inline, protected, virtual, inherited]
+
+ + + + + +
+   + + +

+xmlBreakLine implementation +

+ +

+Reimplemented in NLMISC::COXml. +

+Definition at line 845 of file stream.h. +

+Referenced by NLMISC::IStream::xmlBreakLine(). +

+

00845 { return true; };
+
+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::IStream::xmlComment const char *  comment  )  [inline, inherited]
+
+ + + + + +
+   + + +

+xmlComment() insert a comment line in the XML stream.

+

Returns:
true if the comment is added, return false if no node is opened.
+ +

+Definition at line 811 of file stream.h. +

+References NLMISC::IStream::_XML, comment(), and NLMISC::IStream::xmlCommentInternal(). +

+

00812         {
+00813                 // XML Mode ?
+00814                 if (_XML)
+00815                 {
+00816                         return xmlCommentInternal (comment);
+00817                 }
+00818 
+00819                 // Return ok
+00820                 return true;
+00821         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual bool NLMISC::IStream::xmlCommentInternal const char *  comment  )  [inline, protected, virtual, inherited]
+
+ + + + + +
+   + + +

+xmlComment implementation +

+ +

+Reimplemented in NLMISC::COXml. +

+Definition at line 848 of file stream.h. +

+Referenced by NLMISC::IStream::xmlComment(). +

+

00848 { return true; };
+
+

+ + + + +
+ + + + + + + + + +
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(). +

+

00760         {
+00761                 // XML Mode ?
+00762                 if (_XML)
+00763                 {
+00764                         return xmlPopInternal ();
+00765                 }
+00766 
+00767                 // Return ok
+00768                 return true;
+00769         }
+
+

+ + + + +
+ + + + + + + + + +
virtual bool NLMISC::IStream::xmlPopInternal  )  [inline, protected, virtual, inherited]
+
+ + + + + +
+   + + +

+xmlPop implementation +

+ +

+Reimplemented in NLMISC::COXml. +

+Definition at line 839 of file stream.h. +

+Referenced by NLMISC::IStream::xmlPop(). +

+

00839 { return true; };
+
+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::IStream::xmlPush const char *  name  )  [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 701 of file stream.h. +

+References NLMISC::IStream::_XML, res, NLMISC::IStream::xmlPushBeginInternal(), and NLMISC::IStream::xmlPushEndInternal(). +

+Referenced by NLLIGO::CZoneRegion::serial(), NLLIGO::CZoneBankElement::serial(), NL3D::CZone::serial(), NL3D::CPatch::serial(), NLMISC::CObjectVector< sint8, false >::serial(), NLMISC::COXml::serial(), NLMISC::COXml::serialBuffer(), NLMISC::IStream::serialCheck(), NLMISC::IStream::serialMap(), NLMISC::IStream::serialMultimap(), NLMISC::IStream::serialSTLContLen(), NLMISC::IStream::serialVector(), NLMISC::IStream::serialVersion(), and NLMISC::IStream::xmlSerial(). +

+

00702         {
+00703                 // XML Mode ?
+00704                 if (_XML)
+00705                 {
+00706                         // Open the header
+00707                         bool res=xmlPushBeginInternal (name);
+00708                         if (res)
+00709                                 // close the header
+00710                                 xmlPushEndInternal ();
+00711                         // Return the result
+00712                         return res;
+00713                 }
+00714 
+00715                 // Return ok
+00716                 return true;
+00717         }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::IStream::xmlPushBegin const char *  name  )  [inline, inherited]
+
+ + + + + +
+   + + +

+xmlBreakLine() insert a break line in the XML stream.

+

Returns:
true if the break line is added, return false if no node is opened.
+ +

+Definition at line 725 of file stream.h. +

+References NLMISC::IStream::_XML, and NLMISC::IStream::xmlPushBeginInternal(). +

+Referenced by NLMISC::CObjectVector< sint8, false >::serial(), NLMISC::IStream::serialIStreamable(), NLMISC::IStream::serialMap(), NLMISC::IStream::serialMultimap(), NLMISC::IStream::serialPtr(), NLMISC::IStream::serialSTLCont(), NLMISC::IStream::serialSTLContPtr(), NLMISC::IStream::serialVector(), NLMISC::IStream::serialVectorPolyPtr(), and NLMISC::IStream::serialVectorPtr(). +

+

00726         {
+00727                 // XML Mode ?
+00728                 if (_XML)
+00729                 {
+00730                         return xmlPushBeginInternal (name);
+00731                 }
+00732 
+00733                 // Return ok
+00734                 return true;
+00735         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual bool NLMISC::IStream::xmlPushBeginInternal const char *  name  )  [inline, protected, virtual, inherited]
+
+ + + + + +
+   + + +

+xmlPushBegin implementation +

+ +

+Reimplemented in NLMISC::COXml. +

+Definition at line 833 of file stream.h. +

+Referenced by NLMISC::IStream::xmlPush(), and NLMISC::IStream::xmlPushBegin(). +

+

00833 { return true; };
+
+

+ + + + +
+ + + + + + + + + +
bool NLMISC::IStream::xmlPushEnd  )  [inline, inherited]
+
+ + + + + +
+   + + +

+xmlPushEnd() close the node header.

+

Returns:
true if you can close the node header, false if no node header have been opened with xmlPushBegin().
+ +

+Definition at line 742 of file stream.h. +

+References NLMISC::IStream::_XML, and NLMISC::IStream::xmlPushEndInternal(). +

+Referenced by NLMISC::CObjectVector< sint8, false >::serial(), NLMISC::IStream::serialIStreamable(), NLMISC::IStream::serialMap(), NLMISC::IStream::serialMultimap(), NLMISC::IStream::serialPtr(), NLMISC::IStream::serialSTLCont(), NLMISC::IStream::serialSTLContPtr(), NLMISC::IStream::serialVector(), NLMISC::IStream::serialVectorPolyPtr(), and NLMISC::IStream::serialVectorPtr(). +

+

00743         {
+00744                 // XML Mode ?
+00745                 if (_XML)
+00746                 {
+00747                         return xmlPushEndInternal ();
+00748                 }
+00749 
+00750                 // Return ok
+00751                 return true;
+00752         }
+
+

+ + + + +
+ + + + + + + + + +
virtual bool NLMISC::IStream::xmlPushEndInternal  )  [inline, protected, virtual, inherited]
+
+ + + + + +
+   + + +

+xmlPushEnd implementation +

+ +

+Reimplemented in NLMISC::COXml. +

+Definition at line 836 of file stream.h. +

+Referenced by NLMISC::IStream::xmlPush(), and NLMISC::IStream::xmlPushEnd(). +

+

00836 { return true; };
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::xmlSerial T &  value0,
T &  value1,
T &  value2,
T &  value3,
const char *  nodeName
[inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 683 of file stream.h. +

+References NLMISC::IStream::serial(), NLMISC::IStream::xmlPop(), and NLMISC::IStream::xmlPush(). +

+

00684         {
+00685                 // Open the node
+00686                 xmlPush (nodeName);
+00687                 
+00688                 // Serial the values
+00689                 serial (value0, value1, value2, value3);
+00690 
+00691                 // Close the node
+00692                 xmlPop ();
+00693         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::xmlSerial T &  value0,
T &  value1,
T &  value2,
const char *  nodeName
[inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 671 of file stream.h. +

+References NLMISC::IStream::serial(), NLMISC::IStream::xmlPop(), and NLMISC::IStream::xmlPush(). +

+

00672         {
+00673                 // Open the node
+00674                 xmlPush (nodeName);
+00675                 
+00676                 // Serial the values
+00677                 serial (value0, value1, value2);
+00678 
+00679                 // Close the node
+00680                 xmlPop ();
+00681         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::xmlSerial T &  value0,
T &  value1,
const char *  nodeName
[inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 659 of file stream.h. +

+References NLMISC::IStream::serial(), NLMISC::IStream::xmlPop(), and NLMISC::IStream::xmlPush(). +

+

00660         {
+00661                 // Open the node
+00662                 xmlPush (nodeName);
+00663                 
+00664                 // Serial the values
+00665                 serial (value0, value1);
+00666 
+00667                 // Close the node
+00668                 xmlPop ();
+00669         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::xmlSerial T &  value0,
const char *  nodeName
[inline, inherited]
+
+ + + + + +
+   + + +

+xmlSerial() serial a values into a node. +

+Definition at line 647 of file stream.h. +

+References NLMISC::IStream::serial(), NLMISC::IStream::xmlPop(), and NLMISC::IStream::xmlPush(). +

+Referenced by NLLIGO::CZoneRegion::serial(), NLLIGO::CZoneRegion::SZoneUnit2::serial(), NLLIGO::CZoneRegion::SZoneUnit::serial(), NL3D::CZone::serial(), NL3D::CPatchInfo::CBindInfo::serial(), NL3D::CZone::CPatchConnect::serial(), NL3D::CBorderVertex::serial(), NL3D::CTileElement::serial(), NL3D::CTileColorOldPatchVersion6::serial(), NL3D::CTileColor::serial(), and NL3D::CPatch::serial(). +

+

00648         {
+00649                 // Open the node
+00650                 xmlPush (nodeName);
+00651                 
+00652                 // Serial the value
+00653                 serial (value0);
+00654 
+00655                 // Close the node
+00656                 xmlPop ();
+00657         }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::IStream::xmlSetAttrib const char *  name  )  [inline, inherited]
+
+ + + + + +
+   + + +

+xmlSetAttrib() set the name of the next node header attribute serialised.

+is the name of the node header attribute serialised.

Returns:
true if the attribute name have been set, false if the node header is not open (the call is not between xmlPushBegin and xmlPushEnd)
+ +

+Definition at line 777 of file stream.h. +

+References NLMISC::IStream::_XML, and NLMISC::IStream::xmlSetAttribInternal(). +

+Referenced by NLMISC::CObjectVector< sint8, false >::serial(), NLMISC::IStream::serialIStreamable(), NLMISC::IStream::serialMap(), NLMISC::IStream::serialMultimap(), NLMISC::IStream::serialPtr(), NLMISC::IStream::serialSTLCont(), NLMISC::IStream::serialSTLContPtr(), NLMISC::IStream::serialVector(), NLMISC::IStream::serialVectorPolyPtr(), and NLMISC::IStream::serialVectorPtr(). +

+

00778         {
+00779                 // XML Mode ?
+00780                 if (_XML)
+00781                 {
+00782                         return xmlSetAttribInternal (name);
+00783                 }
+00784 
+00785                 // Return ok
+00786                 return true;
+00787         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual bool NLMISC::IStream::xmlSetAttribInternal const char *  name  )  [inline, protected, virtual, inherited]
+
+ + + + + +
+   + + +

+xmlBreakLine implementation +

+ +

+Reimplemented in NLMISC::COXml. +

+Definition at line 842 of file stream.h. +

+Referenced by NLMISC::IStream::xmlSetAttrib(). +

+

00842 { return true; };
+
+


Field Documentation

+

+ + + + +
+ + +
CObjectVector<uint8, false> NLMISC::CMemStream::_Buffer [protected, 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: +
Generated on Tue Mar 16 13:36:57 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1