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/a02270.html | 5786 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 5786 insertions(+) create mode 100644 docs/doxygen/nel/a02270.html (limited to 'docs/doxygen/nel/a02270.html') diff --git a/docs/doxygen/nel/a02270.html b/docs/doxygen/nel/a02270.html new file mode 100644 index 00000000..21108171 --- /dev/null +++ b/docs/doxygen/nel/a02270.html @@ -0,0 +1,5786 @@ + + +NeL: NLMISC::IStream class Reference + + + +

NLMISC::IStream Class Reference

#include <stream.h> +

Inheritance diagram for NLMISC::IStream: +

+ + + + + + + + + + + +

Detailed Description

+A IO stream interface. This is the base interface for stream objects. Differents kind of streams may be implemented, by specifying serialBuffer() methods.

+Deriver Use:

+The deriver must:

construct object specifying his type, see IStream(). A stream may be setup Input or Output at construction, but cannot change during his life.
specify serialBuffer(), to save or load pack of bytes.
specify serialBit(), to save or load a bit.
call resetPtrTable() when the stream reset itself (e.g.: CIFile::close() )

+Sample of streams: COutMemoryStream, CInFileStream ...

+Client Use:

+An object which can be serialized, must provide a "void serial(IStream &)" method. In this method, he can use any of the IStream method to help himself like:

serial() with a base type (uint32, string, char...), or even with an object which provide "void serial(IStream &)"
template serial(T0&, T1&, ...) to serialize multiple object/variables in one call (up to 6).
serialCont() to serialize containers.
serialVersion() to check/store a version number of his class.
serialPtr() to use the ptr support of IStream (see serialPtr() for more information)
isReading() to know if he write in the stream, or if he read.

+The using is very simple as shown in this example:

 class A
+ {
+ public:
+        float   x;
+        uint32  y;
+        Class1  a;              // this class must provide a serial() method too...
+        Base    *c,*d;  // Base must derive from IStreamable
+        vector<Class2>  tab;
+
+ public:
+        void    serial(IStream &f)
+        {
+                sint    streamver= f.serialVersion(3);
+                f.serial(x,y,a);
+                f.serialPtr(c);
+                f.serialCont(tab);
+                if(streamver>=2)
+                        f.serialPtr(d);
+        }
+ };
+

+NB: YOU CANNOT use serial with a int / uint / sint type, since those type have unspecified length.

Author:

Lionel Berenguier

+Vianney Lecroart

+Nevrax France

Date:: 2000

+ +

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

Seek fonctionnality
enum TSeekOrigin { begin, +current, +end + }
virtual sint32 getPos ()
virtual std::string getStreamName () const
virtual bool seek (sint32 offset, TSeekOrigin origin)

standard STL containers serialisation.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<>, map<>, multimap<> Support up to sint32 length containers.
See also:
serialContPtr() serialContPolyPtr()
+

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, class Allocator> void serialCont (std::vector< T, Allocator > &cont)
Specialisation of serialCont() for vector<bool>.

XML implementation interface
void resetPtrTable ()
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

Public Types

Public Member Functions
bool isReading () const
Is this stream a Read/Input stream?

IStream (const IStream &other)
Copy constructor.

IStream (bool inputStream)
bool isXML () const
IStream & operator= (const IStream &other)
Assignment operator.

template<class T> void serial (T &obj)
virtual void serialBufferWithSize (uint8 *buf, uint32 len)
template<class T> void serialEnum (T &em)
Template enum serialisation. Serialized as a sint32.

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

virtual ~IStream ()
Destructor.

XML implementation interface
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.
+

virtual void serialBit (bool &bit)=0
virtual void serialBuffer (uint8 *buf, uint len)=0

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

Protected Member Functions
template<class T> void serialVector (T &cont)

Private Types
typedef std::hash_map< uint64,
+ void *, CHashFunctionUInt64
+>::iterator ItIdMap
typedef std::hash_map< uint64,
+ void *, CHashFunctionUInt64
+>::value_type ValueIdMap

Private Member Functions
void serialIStreamable (IStreamable *&ptr)
template<class T> void serialMap (T &cont)
template<class T> void serialMultimap (T &cont)
template<class T> void serialSTLCont (T &cont)
template<class T> void serialSTLContLen (T &cont, sint32 len)
template<class T> void serialSTLContLenPolyPtr (T &cont, sint32 len)
template<class T> void serialSTLContLenPtr (T &cont, sint32 len)
template<class T> void serialSTLContPolyPtr (T &cont)
template<class T> void serialSTLContPtr (T &cont)
template<class T> void serialVectorPolyPtr (T &cont)
template<class T> void serialVectorPtr (T &cont)

Private Attributes
std::hash_map< uint64, void *,
+ CHashFunctionUInt64 > _IdMap
bool _InputStream
uint32 _NextSerialPtrId
bool _XML

Static Private Attributes
bool _ThrowOnNewer = true
bool _ThrowOnOlder = false
+

Member Typedef Documentation

+ + + + +
+ + +
typedef std::hash_map<uint64, void*, CHashFunctionUInt64>::iterator NLMISC::IStream::ItIdMap [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 891 of file stream.h. +
+Referenced by serialIStreamable(), and serialPtr().
+

+ + + + +
+ + +
typedef std::hash_map<uint64, void*, CHashFunctionUInt64>::value_type NLMISC::IStream::ValueIdMap [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 892 of file stream.h. +
+Referenced by serialIStreamable(), and serialPtr().
+

Member Enumeration Documentation

+ + + + +
+ + +
enum NLMISC::IStream::TSeekOrigin +
+
+ + + + + +
+ + + +
+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::IStream::IStream ( bool inputStream ) [inline, explicit]
+
+ + + + + +
+ + + +
+Constructor. Notice that those behavior can be set at construction only.
Parameters:
+ + +
inputStream is the stream an Input (read) stream?
+
+ +
+Definition at line 55 of file stream_inline.h. +
+References _InputStream, _XML, and resetPtrTable(). +
+
00056 { +00057 _InputStream= inputStream; +00058 _XML = false; +00059 resetPtrTable(); +00060 } +

+

+ + + + +
+ + + + + + + + + +
virtual NLMISC::IStream::~IStream ( ) [inline, virtual]
+
+ + + + + +
+ + + +
+Destructor. +
+ +
+Definition at line 209 of file stream.h. +
+
00209 {} +

+

+ + + + +
+ + + + + + + + + + +
NLMISC::IStream::IStream ( const IStream & other )
+
+ + + + + +
+ + + +
+Copy constructor. +
+ +
+Definition at line 89 of file stream.cpp. +
+References _XML, and operator=(). +
+
00090 { +00091 operator=( other ); +00092 +00093 // By default, mode _XML is off +00094 _XML = false; +00095 } +

+

Member Function Documentation

+ + + + +
+ + + + + + + + + +
sint32 NLMISC::IStream::getPos ( ) [virtual]
+
+ + + + + +
+ + + +
+Get the location of the stream pointer.
+NB: If the stream doesn't support the seek fonctionnality, it throw 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 in NLAIAGENT::CMsgIStream, NLMISC::CIFile, NLMISC::COFile, and NLMISC::CMemStream. +
+Definition at line 407 of file stream.cpp. +
+References sint32. +
+Referenced by NLMISC::CBitmap::readTGA(). +
+
00408 { +00409 throw ESeekNotSupported(*this); +00410 } +

+

+ + + + +
+ + + + + + + + + +
string NLMISC::IStream::getStreamName ( ) const [virtual]
+
+ + + + + +
+ + + +
+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]
+
+ + + + + +
+ + + +
+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 _ThrowOnNewer, and _ThrowOnOlder. +
+
00079 { +00080 throwOnOlder=_ThrowOnOlder; +00081 throwOnNewer=_ThrowOnNewer; +00082 } +

+

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

+

+ + + + +
+ + + + + + + + + + +
IStream & NLMISC::IStream::operator= ( const IStream & other )
+
+ + + + + +
+ + + +
+Assignment operator. +
+ +
+Definition at line 101 of file stream.cpp. +
+References _InputStream, and resetPtrTable(). +
+Referenced by IStream(). +
+
00102 { +00103 _InputStream = other._InputStream; +00104 resetPtrTable(); +00105 return *this; +00106 } +

+

+ + + + +
+ + + + + + + + + +
void NLMISC::IStream::resetPtrTable ( ) [protected]
+
+ + + + + +
+ + + +
+for Deriver: reset the PtrTable in the stream. If Derived stream provide reset()-like methods, they must call this method in their reset() methods. For example, CFile::close() must call it, so it will work correctly with next serialPtr() +
+Reimplemented in NLMISC::CMemStream. +
+Definition at line 253 of file stream.cpp. +
+References _IdMap, and _NextSerialPtrId. +
+Referenced by NLMISC::CIFile::close(), NLMISC::COXml::init(), NLMISC::COFile::internalClose(), IStream(), and operator=(). +
+
00254 { +00255 _IdMap.clear(); +00256 _NextSerialPtrId = 1; // Start at 1 because 0 is the NULL pointer +00257 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLMISC::IStream::seek ( sint32 offset,
TSeekOrigin origin
) [virtual]
+
+ + + + + +
+ + + +
+Moves the stream pointer to a specified location.
+NB: If the stream doesn't support the seek fonctionnality, it throw 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 in NLMISC::CMemStream. +
+Definition at line 401 of file stream.cpp. +
+References offset, and sint32. +
+Referenced by NLMISC::CBitmap::load(), NL3D::CMeshMRMGeom::loadNextLod(), NLMISC::CBitmap::loadSize(), NLMISC::CBitmap::readDDS(), and NLMISC::CBitmap::readTGA(). +
+
00402 { +00403 throw ESeekNotSupported(*this); +00404 return false; +00405 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T0, class T1, class T2, class T3, class T4, class T5>
void NLMISC::IStream::serial ( T0 & a,
T1 & b,
T2 & c,
T3 & d,
T4 & e,
T5 & f
) [inline]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLMISC::CMemStream, and NLMISC::CStringStream. +
+Definition at line 313 of file stream.h. +
+References serial(). +
+
00314 { 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::IStream::serial ( T0 & a,
T1 & b,
T2 & c,
T3 & d,
T4 & e
) [inline]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLMISC::CMemStream, and NLMISC::CStringStream. +
+Definition at line 310 of file stream.h. +
+References serial(). +
+
00311 { serial(a); serial(b); serial(c); serial(d); serial(e);} +

+

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

+

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

+

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

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serial ( ucstring & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Definition at line 304 of file stream_inline.h. +
+References isReading(), len, serial(), sint, and sint32. +
+
00305 { +00306 sint32 len=0; +00307 // Read/Write the length. +00308 if(isReading()) +00309 { +00310 serial(len); +00311 b.resize(len); +00312 } +00313 else +00314 { +00315 len= b.size(); +00316 serial(len); +00317 } +00318 // Read/Write the string. +00319 for(sint i=0;i<len;i++) +00320 serial(b[i]); +00321 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serial ( std::string & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Definition at line 277 of file stream_inline.h. +
+References isReading(), len, nlwarning, serial(), sint, and sint32. +
+
00278 { +00279 sint32 len=0; +00280 // Read/Write the length. +00281 if(isReading()) +00282 { +00283 serial(len); +00284 // nlassert( len<1000000 ); // limiting string size +00285 if (len>1000000) +00286 { +00287 nlwarning("Trying to serialize a string of %u character !", len); +00288 throw NLMISC::EStreamOverflow(); +00289 } +00290 b.resize(len); +00291 } +00292 else +00293 { +00294 len= b.size(); +00295 serial(len); +00296 } +00297 // Read/Write the string. +00298 for(sint i=0;i<len;i++) +00299 serial(b[i]); +00300 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serial ( char & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Definition at line 270 of file stream_inline.h. +
+References serialBuffer(), and uint8. +
+
00271 { +00272 serialBuffer((uint8 *)&b, 1); +00273 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serial ( bool & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Definition at line 263 of file stream_inline.h. +
+References serialBit(). +
+
00264 { +00265 serialBit(b); +00266 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serial ( double & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Definition at line 241 of file stream_inline.h. +
+References isReading(), NLMISC_BSWAP64, serialBuffer(), uint64, uint8, and v. +
+
00242 { +00243 #ifdef NL_LITTLE_ENDIAN +00244 serialBuffer((uint8 *)&b, 8); +00245 #else // NL_LITTLE_ENDIAN +00246 uint64 v; +00247 if(isReading()) +00248 { +00249 serialBuffer((uint8 *)&v, 8); +00250 NLMISC_BSWAP64(v); +00251 b=*((double*)&v); +00252 } +00253 else +00254 { +00255 v=*((uint64*)&b); +00256 NLMISC_BSWAP64(v); +00257 serialBuffer((uint8 *)&v, 8); +00258 } +00259 #endif // NL_LITTLE_ENDIAN +00260 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serial ( float & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Definition at line 219 of file stream_inline.h. +
+References isReading(), NLMISC_BSWAP32, serialBuffer(), uint32, uint8, and v. +
+
00220 { +00221 #ifdef NL_LITTLE_ENDIAN +00222 serialBuffer((uint8 *)&b, 4); +00223 #else // NL_LITTLE_ENDIAN +00224 uint32 v; +00225 if(isReading()) +00226 { +00227 serialBuffer((uint8 *)&v, 4); +00228 NLMISC_BSWAP32(v); +00229 b=*((float*)&v); +00230 } +00231 else +00232 { +00233 v=*((uint32*)&b); +00234 NLMISC_BSWAP32(v); +00235 serialBuffer((uint8 *)&v, 4); +00236 } +00237 #endif // NL_LITTLE_ENDIAN +00238 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serial ( sint64 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Definition at line 197 of file stream_inline.h. +
+References isReading(), NLMISC_BSWAP64, serialBuffer(), sint64, uint64, uint8, and v. +
+
00198 { +00199 #ifdef NL_LITTLE_ENDIAN +00200 serialBuffer((uint8 *)&b, 8); +00201 #else // NL_LITTLE_ENDIAN +00202 uint64 v; +00203 if(isReading()) +00204 { +00205 serialBuffer((uint8 *)&v, 8); +00206 NLMISC_BSWAP64(v); +00207 b=v; +00208 } +00209 else +00210 { +00211 v=b; +00212 NLMISC_BSWAP64(v); +00213 serialBuffer((uint8 *)&v, 8); +00214 } +00215 #endif // NL_LITTLE_ENDIAN +00216 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serial ( uint64 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Definition at line 175 of file stream_inline.h. +
+References isReading(), NLMISC_BSWAP64, serialBuffer(), uint64, uint8, and v. +
+
00176 { +00177 #ifdef NL_LITTLE_ENDIAN +00178 serialBuffer((uint8 *)&b, 8); +00179 #else // NL_LITTLE_ENDIAN +00180 uint64 v; +00181 if(isReading()) +00182 { +00183 serialBuffer((uint8 *)&v, 8); +00184 NLMISC_BSWAP64(v); +00185 b=v; +00186 } +00187 else +00188 { +00189 v=b; +00190 NLMISC_BSWAP64(v); +00191 serialBuffer((uint8 *)&v, 8); +00192 } +00193 #endif // NL_LITTLE_ENDIAN +00194 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serial ( sint32 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Definition at line 153 of file stream_inline.h. +
+References isReading(), NLMISC_BSWAP32, serialBuffer(), sint32, uint32, uint8, and v. +
+
00154 { +00155 #ifdef NL_LITTLE_ENDIAN +00156 serialBuffer((uint8 *)&b, 4); +00157 #else // NL_LITTLE_ENDIAN +00158 uint32 v; +00159 if(isReading()) +00160 { +00161 serialBuffer((uint8 *)&v, 4); +00162 NLMISC_BSWAP32(v); +00163 b=v; +00164 } +00165 else +00166 { +00167 v=b; +00168 NLMISC_BSWAP32(v); +00169 serialBuffer((uint8 *)&v, 4); +00170 } +00171 #endif // NL_LITTLE_ENDIAN +00172 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serial ( uint32 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Definition at line 131 of file stream_inline.h. +
+References isReading(), NLMISC_BSWAP32, serialBuffer(), uint32, uint8, and v. +
+
00132 { +00133 #ifdef NL_LITTLE_ENDIAN +00134 serialBuffer((uint8 *)&b, 4); +00135 #else // NL_LITTLE_ENDIAN +00136 uint32 v; +00137 if(isReading()) +00138 { +00139 serialBuffer((uint8 *)&v, 4); +00140 NLMISC_BSWAP32(v); +00141 b=v; +00142 } +00143 else +00144 { +00145 v=b; +00146 NLMISC_BSWAP32(v); +00147 serialBuffer((uint8 *)&v, 4); +00148 } +00149 #endif // NL_LITTLE_ENDIAN +00150 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serial ( sint16 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Definition at line 109 of file stream_inline.h. +
+References isReading(), NLMISC_BSWAP16, serialBuffer(), sint16, uint16, uint8, and v. +
+
00110 { +00111 #ifdef NL_LITTLE_ENDIAN +00112 serialBuffer((uint8 *)&b, 2); +00113 #else // NL_LITTLE_ENDIAN +00114 uint16 v; +00115 if(isReading()) +00116 { +00117 serialBuffer((uint8 *)&v, 2); +00118 NLMISC_BSWAP16(v); +00119 b=v; +00120 } +00121 else +00122 { +00123 v=b; +00124 NLMISC_BSWAP16(v); +00125 serialBuffer((uint8 *)&v, 2); +00126 } +00127 #endif // NL_LITTLE_ENDIAN +00128 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serial ( uint16 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Definition at line 87 of file stream_inline.h. +
+References isReading(), NLMISC_BSWAP16, serialBuffer(), uint16, uint8, and v. +
+
00088 { +00089 #ifdef NL_LITTLE_ENDIAN +00090 serialBuffer((uint8 *)&b, 2); +00091 #else // NL_LITTLE_ENDIAN +00092 uint16 v; +00093 if(isReading()) +00094 { +00095 serialBuffer((uint8 *)&v, 2); +00096 NLMISC_BSWAP16(v); +00097 b=v; +00098 } +00099 else +00100 { +00101 v=b; +00102 NLMISC_BSWAP16(v); +00103 serialBuffer((uint8 *)&v, 2); +00104 } +00105 #endif // NL_LITTLE_ENDIAN +00106 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serial ( sint8 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Definition at line 81 of file stream_inline.h. +
+References serialBuffer(), sint8, and uint8. +
+
00082 { +00083 serialBuffer((uint8 *)&b, 1); +00084 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serial ( uint8 & b ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Definition at line 75 of file stream_inline.h. +
+References serialBuffer(), and uint8. +
+
00076 { +00077 serialBuffer((uint8 *)&b, 1); +00078 } +

+

+ + + + +
+ + + + + + + + + + +
virtual void NLMISC::IStream::serialBit ( bool & bit ) [pure virtual]
+
+ + + + + +
+ + + +
+ +
+Implemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CIFile, NLMISC::COFile, NLMISC::CMemStream, NLMISC::COXml, and NLMISC::CStringStream. +
+Referenced by serial().
+

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

+

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

+

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

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
virtual void NLMISC::IStream::serialBuffer ( uint8 * buf,
uint len
) [pure virtual]
+
+ + + + + +
+ + + +
+Method to be specified by the Deriver.
Warning:
Do not call these methods from outside, unless you really know what you are doing. Using them instead of serial() can lead to communication problems between different platforms !
+ +
+Implemented in NLAIAGENT::CMsgIStream, NLAIAGENT::CMsgOStream, NLMISC::CBitMemStream, NLMISC::CIFile, NLMISC::COFile, NLMISC::CMemStream, and NLMISC::COXml. +
+Referenced by NLMISC::CBitmap::readDDS(), NLMISC::CBitmap::readTGA(), NL3D::CTileNoiseMap::serial(), serial(), serialBufferWithSize(), serialCont(), serialMemStream(), NL3D::CVertexBuffer::serialSubset(), and NLMISC::xmlOutputWriteCallbackForNeL().
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
virtual void NLMISC::IStream::serialBufferWithSize ( uint8 * buf,
uint32 len
) [inline, virtual]
+
+ + + + + +
+ + + +
+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, serial(), serialBuffer(), uint32, and uint8. +
+
00878 { +00879 serial (len); +00880 serialBuffer (buf, len); +00881 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialCheck ( const T & value ) [inline]
+
+ + + + + +
+ + + +
+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 isReading(), serial(), value, xmlPop(), and 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 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serialCont ( std::vector< bool > & cont ) [virtual]
+
+ + + + + +
+ + + +
+Specialisation of serialCont() for vector<bool>. +
+ +
+Reimplemented in NLMISC::CBitMemStream, NLMISC::CMemStream, and NLMISC::CStringStream. +
+Definition at line 356 of file stream.cpp. +
+References isReading(), len, serial(), serialBuffer(), sint, sint32, uint, and uint8. +
+
00357 { +00358 sint32 len=0; +00359 vector<uint8> vec; +00360 +00361 if(isReading()) +00362 { +00363 serial(len); +00364 cont.resize(len); +00365 +00366 if (len != 0) +00367 { +00368 // read as uint8*. +00369 sint lb= (len+7)/8; +00370 vec.resize(lb); +00371 serialBuffer( (uint8*)&(*vec.begin()) , lb); +00372 for(sint i=0;i<len;i++) +00373 { +00374 uint bit= (vec[i>>3]>>(i&7)) & 1; +00375 cont[i]= bit?true:false; +00376 } +00377 } +00378 } +00379 else +00380 { +00381 len= cont.size(); +00382 serial(len); +00383 +00384 if (len != 0) +00385 { +00386 // write as uint8*. +00387 sint lb= (len+7)/8; +00388 vec.resize(lb); +00389 fill_n(vec.begin(), lb, 0); +00390 for(sint i=0;i<len;i++) +00391 { +00392 uint bit= cont[i]?1:0; +00393 vec[i>>3]|= bit<<(i&7); +00394 } +00395 serialBuffer( (uint8*)&(*vec.begin()) , lb); +00396 } +00397 } +00398 +00399 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serialCont ( std::vector< sint8 > & cont ) [virtual]
+
+ + + + + +
+ + + +
+Specialisation of serialCont() for vector<sint8>. +
+ +
+Reimplemented in NLMISC::CBitMemStream, NLMISC::CMemStream, and NLMISC::CStringStream. +
+Definition at line 337 of file stream.cpp. +
+References isReading(), len, serial(), serialBuffer(), sint32, and uint8. +
+
00338 { +00339 sint32 len=0; +00340 if(isReading()) +00341 { +00342 serial(len); +00343 cont.resize(len); +00344 if (len != 0) +00345 serialBuffer( (uint8*)&(*cont.begin()) , len); +00346 } +00347 else +00348 { +00349 len= cont.size(); +00350 serial(len); +00351 if (len != 0) +00352 serialBuffer( (uint8*)&(*cont.begin()) , len); +00353 } +00354 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serialCont ( std::vector< uint8 > & cont ) [virtual]
+
+ + + + + +
+ + + +
+Specialisation of serialCont() for vector<uint8>. +
+ +
+Reimplemented in NLMISC::CBitMemStream, NLMISC::CMemStream, and NLMISC::CStringStream. +
+Definition at line 318 of file stream.cpp. +
+References isReading(), len, serial(), serialBuffer(), sint32, and uint8. +
+
00319 { +00320 sint32 len=0; +00321 if(isReading()) +00322 { +00323 serial(len); +00324 cont.resize(len); +00325 if (len != 0) +00326 serialBuffer( (uint8*)&(*cont.begin()) , len); +00327 } +00328 else +00329 { +00330 len= cont.size(); +00331 serial(len); +00332 if (len != 0) +00333 serialBuffer( (uint8*)&(*cont.begin()) , len); +00334 } +00335 } +

+

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

+

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

+

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

+

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

+

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

+

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

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPolyPtr ( std::multiset< T > & cont ) [inline]
+
+ + + + + +
+ + + +
+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 serialSTLContPolyPtr(). +
+
00379 {serialSTLContPolyPtr(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPolyPtr ( std::set< T > & cont ) [inline]
+
+ + + + + +
+ + + +
+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 serialSTLContPolyPtr(). +
+
00377 {serialSTLContPolyPtr(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPolyPtr ( std::deque< T > & cont ) [inline]
+
+ + + + + +
+ + + +
+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 serialSTLContPolyPtr(). +
+
00375 {serialSTLContPolyPtr(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialContPolyPtr ( std::list< T > & cont ) [inline]
+
+ + + + + +
+ + + +
+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 serialSTLContPolyPtr(). +
+
00373 {serialSTLContPolyPtr(cont);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T, class Allocator>
void NLMISC::IStream::serialContPolyPtr ( std::vector< T, Allocator > & cont ) [inline]
+
+ + + + + +
+ + + +
+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 serialVectorPolyPtr(). +
+Referenced by NL3D::CAnimation::serial(). +
+
00371 {serialVectorPolyPtr(cont);} +

+

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

+

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

+

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

+

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

+

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

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialEnum ( T & em ) [inline]
+
+ + + + + +
+ + + +
+Template enum serialisation. Serialized as a sint32. +
+ +
+Definition at line 261 of file stream.h. +
+References isReading(), 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::IStream::serialIStreamable ( IStreamable *& ptr ) [private]
+
+ + + + + +
+ + + +
+ +
+Definition at line 115 of file stream.cpp. +
+References _IdMap, _NextSerialPtrId, isReading(), ItIdMap, nlassert, serial(), uint, uint64, ValueIdMap, xmlPop(), xmlPushBegin(), xmlPushEnd(), and xmlSetAttrib(). +
+Referenced by serialPolyPtr(). +
+
00116 { +00117 uint64 node=0; +00118 +00119 // Open a node +00120 xmlPushBegin ("POLYPTR"); +00121 +00122 if(isReading()) +00123 { +00124 // First attribute name +00125 xmlSetAttrib ("id"); +00126 +00127 serial(node); +00128 +00129 if(node==0) +00130 { +00131 ptr=NULL; +00132 +00133 // Close the node header +00134 xmlPushEnd (); +00135 } +00136 else +00137 { +00138 ItIdMap it; +00139 it= _IdMap.find(node); +00140 +00141 // Test if object already created/read. +00142 if( it==_IdMap.end() ) +00143 { +00144 // Read the class name. +00145 string className; +00146 +00147 // Second attribute name +00148 xmlSetAttrib ("class"); +00149 +00150 serial(className); +00151 +00152 // Close the node header +00153 xmlPushEnd (); +00154 +00155 // Construct object. +00156 ptr= dynamic_cast<IStreamable*> (CClassRegistry::create(className)); +00157 if(ptr==NULL) +00158 #ifdef NL_DEBUG +00159 throw EUnregisteredClass(className); +00160 #else +00161 throw EUnregisteredClass(); +00162 #endif +00163 +00164 +00165 #ifdef NL_DEBUG +00166 nlassert(CClassRegistry::checkObject(ptr)); +00167 #endif +00168 +00169 // Insert the node. +00170 _IdMap.insert( ValueIdMap(node, ptr) ); +00171 +00172 // Read the object! +00173 ptr->serial(*this); +00174 } +00175 else +00176 { +00177 ptr= static_cast<IStreamable*>(it->second); +00178 +00179 // Close the node header +00180 xmlPushEnd (); +00181 } +00182 } +00183 } +00184 else +00185 { +00186 if(ptr==NULL) +00187 { +00188 node= 0; +00189 +00190 // First attribute name +00191 xmlSetAttrib ("id"); +00192 +00193 serial(node); +00194 +00195 // Close the node header +00196 xmlPushEnd (); +00197 } +00198 else +00199 { +00200 // Assume that prt size is an int size +00201 nlassert(sizeof(uint) == sizeof(void *)); +00202 +00203 ItIdMap it; +00204 it = _IdMap.find((uint64)(uint)ptr); +00205 +00206 // Test if object has been already written +00207 if( it==_IdMap.end() ) +00208 { +00209 // Not yet written +00210 +00211 // Get the next available ID +00212 node = _NextSerialPtrId++; +00213 +00214 // Serial the id +00215 xmlSetAttrib ("id"); +00216 serial(node); +00217 +00218 // Insert the pointer in the map with the id +00219 _IdMap.insert( ValueIdMap((uint64)(uint)ptr, (void*)(uint)node) ); +00220 +00221 #ifdef NL_DEBUG +00222 nlassert(CClassRegistry::checkObject(ptr)); +00223 #endif +00224 +00225 // Write the class name. +00226 string className=ptr->getClassName(); +00227 +00228 // Second attribute name +00229 xmlSetAttrib ("class"); +00230 serial(className); +00231 +00232 // Close the node header +00233 xmlPushEnd (); +00234 +00235 // Write the object! +00236 ptr->serial(*this); +00237 } +00238 else +00239 { +00240 // Write only the object id +00241 xmlSetAttrib ("id"); +00242 node = (uint64)(uint)(it->second); +00243 serial(node); +00244 xmlPushEnd (); +00245 } +00246 } +00247 } +00248 +00249 // Close the node +00250 xmlPop (); +00251 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialMap ( T & cont ) [inline, private]
+
+ + + + + +
+ + + +
+STL map<> Support up to sint32 length containers.
+the object T must provide:
+
typedef iterator; (providing operator++() and operator*())
+
typedef value_type; (must be a std::pair<>)
+
typedef key_type; (must be the type of the key)
+
void clear();
+
size_type size() const;
+
iterator begin();
+
iterator end();
+
iterator insert(iterator it, const value_type& x);
+
+Known Supported containers: map<>
Parameters:
+ + +
cont a STL map<> container.
+
+ +
+Definition at line 1360 of file stream.h. +
+References isReading(), len, serial(), sint, sint32, xmlPop(), xmlPush(), xmlPushBegin(), xmlPushEnd(), and xmlSetAttrib(). +
+Referenced by serialCont(). +
+
01361 { +01362 typedef typename T::value_type __value_type; +01363 typedef typename T::key_type __key_type; +01364 typedef typename T::iterator __iterator; +01365 +01366 // Open a node header +01367 xmlPushBegin ("MAP"); +01368 +01369 // Attrib size +01370 xmlSetAttrib ("size"); +01371 +01372 sint32 len; +01373 if(isReading()) +01374 { +01375 cont.clear(); +01376 serial(len); +01377 +01378 // Close the node header +01379 xmlPushEnd (); +01380 +01381 for(sint i=0;i<len;i++) +01382 { +01383 /* __value_type v; +01384 +01385 xmlPush ("KEY"); +01386 +01387 serial ( const_cast<__key_type&>(v.first) ); +01388 +01389 xmlPop (); +01390 +01391 +01392 xmlPush ("ELM"); +01393 +01394 serial (v.second); +01395 +01396 xmlPop (); +01397 +01398 cont.insert(cont.end(), v); +01399 */ +01400 // MALKAV 05/07/02 : prevent a copy of the value, copy the key instead +01401 __key_type k; +01402 +01403 xmlPush ("KEY"); +01404 serial ( k ); +01405 xmlPop (); +01406 +01407 +01408 xmlPush ("ELM"); +01409 serial (cont[k]); +01410 xmlPop (); +01411 } +01412 } +01413 else +01414 { +01415 len= cont.size(); +01416 serial(len); +01417 __iterator it= cont.begin(); +01418 +01419 // Close the node header +01420 xmlPushEnd (); +01421 +01422 for(sint i=0;i<len;i++, it++) +01423 { +01424 xmlPush ("KEY"); +01425 +01426 serial( const_cast<__key_type&>((*it).first) ); +01427 +01428 xmlPop (); +01429 +01430 xmlPush ("ELM"); +01431 +01432 serial((*it).second); +01433 +01434 xmlPop (); +01435 } +01436 } +01437 +01438 // Close the node +01439 xmlPop (); +01440 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::serialMemStream ( CMemStream & b ) [virtual]
+
+ + + + + +
+ + + +
+Serial memstream, bitmemstream... +
+ +
+Definition at line 436 of file stream.cpp. +
+References NLMISC::CMemStream::buffer(), NLMISC::CMemStream::bufferToFill(), isReading(), len, NLMISC::CMemStream::length(), NLMISC::CMemStream::resetBufPos(), serial(), 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::serialMultimap ( T & cont ) [inline, private]
+
+ + + + + +
+ + + +
+STL map<> and multimap<> serialisation. Support up to sint32 length containers.
+the object T must provide:
+
typedef iterator; (providing operator++() and operator*())
+
typedef value_type; (must be a std::pair<>)
+
typedef key_type; (must be the type of the key)
+
void clear();
+
size_type size() const;
+
iterator begin();
+
iterator end();
+
iterator insert(iterator it, const value_type& x);
+
+Known Supported containers: map<>, multimap<>.
Parameters:
+ + +
cont a STL map<> or multimap<> container.
+
+ +
+Definition at line 1271 of file stream.h. +
+References isReading(), len, serial(), sint, sint32, v, xmlPop(), xmlPush(), xmlPushBegin(), xmlPushEnd(), and xmlSetAttrib(). +
+Referenced by serialCont(). +
+
01272 { +01273 typedef typename T::value_type __value_type; +01274 typedef typename T::key_type __key_type; +01275 typedef typename T::iterator __iterator; +01276 +01277 // Open a node header +01278 xmlPushBegin ("MULTIMAP"); +01279 +01280 // Attrib size +01281 xmlSetAttrib ("size"); +01282 +01283 sint32 len; +01284 if(isReading()) +01285 { +01286 cont.clear(); +01287 serial(len); +01288 +01289 // Close the node header +01290 xmlPushEnd (); +01291 +01292 for(sint i=0;i<len;i++) +01293 { +01294 __value_type v; +01295 +01296 xmlPush ("KEY"); +01297 +01298 serial ( const_cast<__key_type&>(v.first) ); +01299 +01300 xmlPop (); +01301 +01302 +01303 xmlPush ("ELM"); +01304 +01305 serial (v.second); +01306 +01307 xmlPop (); +01308 +01309 cont.insert(cont.end(), v); +01310 } +01311 } +01312 else +01313 { +01314 len= cont.size(); +01315 serial(len); +01316 __iterator it= cont.begin(); +01317 +01318 // Close the node header +01319 xmlPushEnd (); +01320 +01321 for(sint i=0;i<len;i++, it++) +01322 { +01323 xmlPush ("KEY"); +01324 +01325 serial( const_cast<__key_type&>((*it).first) ); +01326 +01327 xmlPop (); +01328 +01329 xmlPush ("ELM"); +01330 +01331 serial((*it).second); +01332 +01333 xmlPop (); +01334 } +01335 } +01336 +01337 // Close the node +01338 xmlPop (); +01339 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialPolyPtr ( T *& ptr ) [inline]
+
+ + + + + +
+ + + +
+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 serialIStreamable(). +
+Referenced by NL3D::CAnimationOptimizer::cloneTrack(), NL3D::CMaterial::CLightMap::serial(), NL3D::CMaterial::serial(), NL3D::CMaterialBase::CAnimatedTexture::serial(), NL3D::CMaterial::CLightMap::serial2(), and serialSTLContLenPolyPtr(). +
+
00493 { IStreamable *p=ptr; serialIStreamable(p); ptr= static_cast<T*>(p);} +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialPtr ( T *& ptr ) [inline]
+
+ + + + + +
+ + + +
+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 _IdMap, _NextSerialPtrId, isReading(), ItIdMap, serial(), uint, uint64, ValueIdMap, xmlPop(), xmlPushBegin(), xmlPushEnd(), and xmlSetAttrib(). +
+Referenced by NL3D::CParticleSystemShape::buildFromPS(), NL3D::CParticleSystemShape::flushTextures(), NL3D::CParticleSystemShape::instanciatePS(), and 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 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialSTLCont ( T & cont ) [inline, private]
+
+ + + + + +
+ + + +
+standard STL containers serialisation. Don't work with map<> and multimap<>. Support up to sint32 length containers.
+the object T must provide:
+
typedef iterator; (providing operator++() and operator*())
+
typedef value_type; (a base type (uint...), or an object providing "void serial(IStream&)" method.)
+
void clear();
+
size_type size() const;
+
iterator begin();
+
iterator end();
+
iterator insert(iterator it, const value_type& x);
+
+Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<>.
Parameters:
+ + +
cont a STL container (vector<>, set<> ...).
+
+ +
+Definition at line 955 of file stream.h. +
+References isReading(), len, serial(), serialSTLContLen(), sint32, xmlPop(), xmlPushBegin(), xmlPushEnd(), and xmlSetAttrib(). +
+Referenced by serialCont(). +
+
00956 { +00957 // Open a node header +00958 xmlPushBegin ("CONTAINER"); +00959 +00960 // Attrib size +00961 xmlSetAttrib ("size"); +00962 +00963 sint32 len=0; +00964 if(isReading()) +00965 { +00966 serial(len); +00967 cont.clear(); +00968 } +00969 else +00970 { +00971 len= cont.size(); +00972 serial(len); +00973 } +00974 +00975 // Close the header +00976 xmlPushEnd (); +00977 +00978 serialSTLContLen(cont, len); +00979 +00980 // Close the node +00981 xmlPop (); +00982 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialSTLContLen ( T & cont,
sint32 len
) [inline, private]
+
+ + + + + +
+ + + +
+standard STL containers serialisation. Don't work with map<> and multimap<>. Support up to sint32 length containers. serialize just len element of the container. +
+Definition at line 905 of file stream.h. +
+References isReading(), len, serial(), sint, sint32, v, xmlPop(), and xmlPush(). +
+Referenced by serialSTLCont(). +
+
00906 { +00907 typedef typename T::value_type __value_type; +00908 typedef typename T::iterator __iterator; +00909 +00910 if(isReading()) +00911 { +00912 for(sint i=0;i<len;i++) +00913 { +00914 xmlPush ("ELM"); +00915 +00916 __value_type v; +00917 serial(v); +00918 (void)cont.insert(cont.end(), v); +00919 +00920 xmlPop (); +00921 } +00922 } +00923 else +00924 { +00925 __iterator it= cont.begin(); +00926 for(sint i=0;i<len;i++, it++) +00927 { +00928 xmlPush ("ELM"); +00929 +00930 serial(const_cast<__value_type&>(*it)); +00931 +00932 xmlPop (); +00933 } +00934 } +00935 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialSTLContLenPolyPtr ( T & cont,
sint32 len
) [inline, private]
+
+ + + + + +
+ + + +
+standard STL containers serialisation. Don't work with map<> and multimap<>. PolyPtr version Support up to sint32 length containers. serialize just len element of the container. +
+Definition at line 1162 of file stream.h. +
+References isReading(), len, serialPolyPtr(), sint, sint32, and v. +
+Referenced by serialSTLContPolyPtr(), and serialVectorPolyPtr(). +
+
01163 { +01164 typedef typename T::value_type __value_type; +01165 typedef typename T::iterator __iterator; +01166 +01167 if(isReading()) +01168 { +01169 for(sint i=0;i<len;i++) +01170 { +01171 __value_type v=NULL; +01172 serialPolyPtr(v); +01173 cont.insert(cont.end(), v); +01174 } +01175 } +01176 else +01177 { +01178 __iterator it= cont.begin(); +01179 for(sint i=0;i<len;i++, it++) +01180 { +01181 serialPolyPtr(const_cast<__value_type&>(*it)); +01182 } +01183 } +01184 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialSTLContLenPtr ( T & cont,
sint32 len
) [inline, private]
+
+ + + + + +
+ + + +
+standard STL containers serialisation. Don't work with map<> and multimap<>. Ptr version. Support up to sint32 length containers. serialize just len element of the container. +
+Definition at line 1056 of file stream.h. +
+References isReading(), len, serialPtr(), sint, sint32, and v. +
+Referenced by serialSTLContPtr(), and serialVectorPtr(). +
+
01057 { +01058 typedef typename T::value_type __value_type; +01059 typedef typename T::iterator __iterator; +01060 +01061 if(isReading()) +01062 { +01063 for(sint i=0;i<len;i++) +01064 { +01065 __value_type v; +01066 serialPtr(v); +01067 cont.insert(cont.end(), v); +01068 } +01069 } +01070 else +01071 { +01072 __iterator it= cont.begin(); +01073 for(sint i=0;i<len;i++, it++) +01074 { +01075 serialPtr(const_cast<__value_type&>(*it)); +01076 } +01077 } +01078 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialSTLContPolyPtr ( T & cont ) [inline, private]
+
+ + + + + +
+ + + +
+standard STL containers serialisation. Don't work with map<> and multimap<>. PolyPtr version Support up to sint32 length containers. +
+Definition at line 1192 of file stream.h. +
+References isReading(), len, serial(), serialSTLContLenPolyPtr(), and sint32. +
+Referenced by serialContPolyPtr(). +
+
01193 { +01194 sint32 len=0; +01195 if(isReading()) +01196 { +01197 serial(len); +01198 cont.clear(); +01199 } +01200 else +01201 { +01202 len= cont.size(); +01203 serial(len); +01204 } +01205 +01206 serialSTLContLenPolyPtr(cont, len); +01207 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialSTLContPtr ( T & cont ) [inline, private]
+
+ + + + + +
+ + + +
+standard STL containers serialisation. Don't work with map<> and multimap<>. Ptr version. Support up to sint32 length containers. +
+Definition at line 1086 of file stream.h. +
+References isReading(), len, serial(), serialSTLContLenPtr(), sint32, xmlPop(), xmlPushBegin(), xmlPushEnd(), and xmlSetAttrib(). +
+Referenced by serialContPtr(). +
+
01087 { +01088 // Open a node header +01089 xmlPushBegin ("CONTAINER"); +01090 +01091 // Attrib size +01092 xmlSetAttrib ("size"); +01093 +01094 sint32 len=0; +01095 if(isReading()) +01096 { +01097 serial(len); +01098 cont.clear(); +01099 } +01100 else +01101 { +01102 len= cont.size(); +01103 serial(len); +01104 } +01105 +01106 // Close the node header +01107 xmlPushEnd (); +01108 +01109 serialSTLContLenPtr(cont, len); +01110 +01111 // Close the node +01112 xmlPop (); +01113 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialVector ( T & cont ) [inline, protected]
+
+ + + + + +
+ + + +
+special version for serializing a vector. Support up to sint32 length containers. +
+Definition at line 992 of file stream.h. +
+References NLMISC::contReset(), isReading(), len, serial(), sint, sint32, xmlPop(), xmlPush(), xmlPushBegin(), xmlPushEnd(), and xmlSetAttrib(). +
+Referenced by NLMISC::CStringStream::serialCont(), 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 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialVectorPolyPtr ( T & cont ) [inline, private]
+
+ + + + + +
+ + + +
+special version for serializing a vector. PolyPtr version Support up to sint32 length containers. +
+Definition at line 1215 of file stream.h. +
+References NLMISC::contReset(), isReading(), len, serial(), serialSTLContLenPolyPtr(), sint32, xmlPop(), xmlPushBegin(), xmlPushEnd(), and xmlSetAttrib(). +
+Referenced by serialContPolyPtr(). +
+
01216 { +01217 typedef typename T::value_type __value_type; +01218 typedef typename T::iterator __iterator; +01219 +01220 // Open a node header +01221 xmlPushBegin ("VECTOR"); +01222 +01223 // Attrib size +01224 xmlSetAttrib ("size"); +01225 +01226 sint32 len=0; +01227 if(isReading()) +01228 { +01229 serial(len); +01230 // special version for vector: adjut good size. +01231 contReset(cont); +01232 cont.reserve(len); +01233 } +01234 else +01235 { +01236 len= cont.size(); +01237 serial(len); +01238 } +01239 +01240 // Close the node header +01241 xmlPushEnd (); +01242 +01243 serialSTLContLenPolyPtr(cont, len); +01244 +01245 // Close the node +01246 xmlPop (); +01247 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::serialVectorPtr ( T & cont ) [inline, private]
+
+ + + + + +
+ + + +
+special version for serializing a vector. Ptr version. Support up to sint32 length containers. +
+Definition at line 1121 of file stream.h. +
+References NLMISC::contReset(), isReading(), len, serial(), serialSTLContLenPtr(), sint32, xmlPop(), xmlPushBegin(), xmlPushEnd(), and xmlSetAttrib(). +
+Referenced by serialContPtr(). +
+
01122 { +01123 typedef typename T::value_type __value_type; +01124 typedef typename T::iterator __iterator; +01125 +01126 // Open a node header +01127 xmlPushBegin ("VECTOR"); +01128 +01129 // Attrib size +01130 xmlSetAttrib ("size"); +01131 +01132 sint32 len=0; +01133 if(isReading()) +01134 { +01135 serial(len); +01136 // special version for vector: adjut good size. +01137 contReset(cont); +01138 cont.reserve(len); +01139 } +01140 else +01141 { +01142 len= cont.size(); +01143 serial(len); +01144 } +01145 +01146 // Close the node header +01147 xmlPushEnd (); +01148 +01149 serialSTLContLenPtr(cont, len); +01150 +01151 // Close the node +01152 xmlPop (); +01153 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::IStream::setInOut ( bool inputStream ) [protected]
+
+ + + + + +
+ + + +
+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 _InputStream. +
+Referenced by NLMISC::CBitMemStream::getSerialItem(), and NLMISC::CMemStream::invert(). +
+
00414 { +00415 _InputStream= inputStream; +00416 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::IStream::setVersionException ( bool throwOnOlder,
bool throwOnNewer
) [static]
+
+ + + + + +
+ + + +
+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 _ThrowOnNewer, and _ThrowOnOlder. +
+
00072 { +00073 _ThrowOnOlder=throwOnOlder; +00074 _ThrowOnNewer=throwOnNewer; +00075 } +

+

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

+

+ + + + +
+ + + + + + + + + +
bool NLMISC::IStream::xmlBreakLine ( ) [inline]
+
+ + + + + +
+ + + +
+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 _XML, and 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]
+
+ + + + + +
+ + + +
+xmlBreakLine implementation +
+ +
+Reimplemented in NLMISC::COXml. +
+Definition at line 845 of file stream.h. +
+Referenced by xmlBreakLine(). +
+
00845 { return true; }; +

+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::IStream::xmlComment ( const char * comment ) [inline]
+
+ + + + + +
+ + + +
+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 _XML, comment(), and 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]
+
+ + + + + +
+ + + +
+xmlComment implementation +
+ +
+Reimplemented in NLMISC::COXml. +
+Definition at line 848 of file stream.h. +
+Referenced by xmlComment(). +
+
00848 { return true; }; +

+

+ + + + +
+ + + + + + + + + +
bool NLMISC::IStream::xmlPop ( ) [inline]
+
+ + + + + +
+ + + +
+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 _XML, and 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(), serialCheck(), serialIStreamable(), serialMap(), serialMultimap(), serialPtr(), serialSTLCont(), serialSTLContLen(), serialSTLContPtr(), serialVector(), serialVectorPolyPtr(), serialVectorPtr(), serialVersion(), and 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]
+
+ + + + + +
+ + + +
+xmlPop implementation +
+ +
+Reimplemented in NLMISC::COXml. +
+Definition at line 839 of file stream.h. +
+Referenced by xmlPop(). +
+
00839 { return true; }; +

+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::IStream::xmlPush ( const char * name ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 701 of file stream.h. +
+References _XML, res, xmlPushBeginInternal(), and 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(), serialCheck(), serialMap(), serialMultimap(), serialSTLContLen(), serialVector(), serialVersion(), and 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]
+
+ + + + + +
+ + + +
+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 _XML, and xmlPushBeginInternal(). +
+Referenced by NLMISC::CObjectVector< sint8, false >::serial(), serialIStreamable(), serialMap(), serialMultimap(), serialPtr(), serialSTLCont(), serialSTLContPtr(), serialVector(), serialVectorPolyPtr(), and 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]
+
+ + + + + +
+ + + +
+xmlPushBegin implementation +
+ +
+Reimplemented in NLMISC::COXml. +
+Definition at line 833 of file stream.h. +
+Referenced by xmlPush(), and xmlPushBegin(). +
+
00833 { return true; }; +

+

+ + + + +
+ + + + + + + + + +
bool NLMISC::IStream::xmlPushEnd ( ) [inline]
+
+ + + + + +
+ + + +
+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 _XML, and xmlPushEndInternal(). +
+Referenced by NLMISC::CObjectVector< sint8, false >::serial(), serialIStreamable(), serialMap(), serialMultimap(), serialPtr(), serialSTLCont(), serialSTLContPtr(), serialVector(), serialVectorPolyPtr(), and 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]
+
+ + + + + +
+ + + +
+xmlPushEnd implementation +
+ +
+Reimplemented in NLMISC::COXml. +
+Definition at line 836 of file stream.h. +
+Referenced by xmlPush(), and xmlPushEnd(). +
+
00836 { return true; }; +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void NLMISC::IStream::xmlSerial ( T & value0,
T & value1,
T & value2,
T & value3,
const char * nodeName
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 683 of file stream.h. +
+References serial(), xmlPop(), and 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]
+
+ + + + + +
+ + + +
+ +
+Definition at line 671 of file stream.h. +
+References serial(), xmlPop(), and 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]
+
+ + + + + +
+ + + +
+ +
+Definition at line 659 of file stream.h. +
+References serial(), xmlPop(), and 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]
+
+ + + + + +
+ + + +
+xmlSerial() serial a values into a node. +
+Definition at line 647 of file stream.h. +
+References serial(), xmlPop(), and 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]
+
+ + + + + +
+ + + +
+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 _XML, and xmlSetAttribInternal(). +
+Referenced by NLMISC::CObjectVector< sint8, false >::serial(), serialIStreamable(), serialMap(), serialMultimap(), serialPtr(), serialSTLCont(), serialSTLContPtr(), serialVector(), serialVectorPolyPtr(), and 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]
+
+ + + + + +
+ + + +
+xmlBreakLine implementation +
+ +
+Reimplemented in NLMISC::COXml. +
+Definition at line 842 of file stream.h. +
+Referenced by xmlSetAttrib(). +
+
00842 { return true; }; +

+

Field Documentation

+ + + + +
+ + +
std::hash_map<uint64, void*, CHashFunctionUInt64> NLMISC::IStream::_IdMap [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 890 of file stream.h. +
+Referenced by resetPtrTable(), serialIStreamable(), and serialPtr().
+

+ + + + +
+ + +
bool NLMISC::IStream::_InputStream [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 884 of file stream.h. +
+Referenced by isReading(), IStream(), operator=(), and setInOut().
+

+ + + + +
+ + +
uint32 NLMISC::IStream::_NextSerialPtrId [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 889 of file stream.h. +
+Referenced by resetPtrTable(), serialIStreamable(), and serialPtr().
+

+ + + + +
+ + +
bool NLMISC::IStream::_ThrowOnNewer = true [static, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 67 of file stream.cpp. +
+Referenced by getVersionException(), serialVersion(), and setVersionException().
+

+ + + + +
+ + +
bool NLMISC::IStream::_ThrowOnOlder = false [static, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 66 of file stream.cpp. +
+Referenced by getVersionException(), serialVersion(), and setVersionException().
+

+ + + + +
+ + +
bool NLMISC::IStream::_XML [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 1443 of file stream.h. +
+Referenced by IStream(), isXML(), setXMLMode(), xmlBreakLine(), xmlComment(), xmlPop(), xmlPush(), xmlPushBegin(), xmlPushEnd(), and xmlSetAttrib().
+

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

Generated on Tue Mar 16 13:48:09 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1


Seek fonctionnality
enum	TSeekOrigin { begin, +current, +end + }
virtual sint32	getPos ()
virtual std::string	getStreamName () const
virtual bool	seek (sint32 offset, TSeekOrigin origin)
standard STL containers serialisation.
Known Supported containers: vector<>, list<>, deque<>, set<>, multiset<>, map<>, multimap<> Support up to sint32 length containers. See also: serialContPtr() serialContPolyPtr() +
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, class Allocator> void	serialCont (std::vector< T, Allocator > &cont)
	Specialisation of serialCont() for vector<bool>.
XML implementation interface
void	resetPtrTable ()
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
Public Types
Public Member Functions
bool	isReading () const
	Is this stream a Read/Input stream?
	IStream (const IStream &other)
	Copy constructor.
	IStream (bool inputStream)
bool	isXML () const
IStream &	operator= (const IStream &other)
	Assignment operator.
template<class T> void	serial (T &obj)
virtual void	serialBufferWithSize (uint8 *buf, uint32 len)
template<class T> void	serialEnum (T &em)
	Template enum serialisation. Serialized as a sint32.
virtual void	serialMemStream (CMemStream &b)
	Serial memstream, bitmemstream...
virtual	~IStream ()
	Destructor.
XML implementation interface
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. +
virtual void	serialBit (bool &bit)=0
virtual void	serialBuffer (uint8 *buf, uint len)=0
Static Public Member Functions
void	getVersionException (bool &throwOnOlder, bool &throwOnNewer)
void	setVersionException (bool throwOnOlder, bool throwOnNewer)
Protected Member Functions
template<class T> void	serialVector (T &cont)
Private Types
typedef std::hash_map< uint64, + void *, CHashFunctionUInt64 +>::iterator	ItIdMap
typedef std::hash_map< uint64, + void *, CHashFunctionUInt64 +>::value_type	ValueIdMap
Private Member Functions
void	serialIStreamable (IStreamable *&ptr)
template<class T> void	serialMap (T &cont)
template<class T> void	serialMultimap (T &cont)
template<class T> void	serialSTLCont (T &cont)
template<class T> void	serialSTLContLen (T &cont, sint32 len)
template<class T> void	serialSTLContLenPolyPtr (T &cont, sint32 len)
template<class T> void	serialSTLContLenPtr (T &cont, sint32 len)
template<class T> void	serialSTLContPolyPtr (T &cont)
template<class T> void	serialSTLContPtr (T &cont)
template<class T> void	serialVectorPolyPtr (T &cont)
template<class T> void	serialVectorPtr (T &cont)
Private Attributes
std::hash_map< uint64, void *, + CHashFunctionUInt64 >	_IdMap
bool	_InputStream
uint32	_NextSerialPtrId
bool	_XML
Static Private Attributes
bool	_ThrowOnNewer = true
bool	_ThrowOnOlder = false