Home

nevrax.com

Nevrax.org News Mailing-list Documentation CVS Bugs License

Documentation                       Search   stream.h Go to the documentation of this file. /* Copyright, 2000 Nevrax Ltd. * * This file is part of NEVRAX NEL. * NEVRAX NEL is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * NEVRAX NEL is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * You should have received a copy of the GNU General Public License * along with NEVRAX NEL; see the file COPYING. If not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, * MA 02111-1307, USA. */ #ifndef NL_STREAM_H #define NL_STREAM_H #include "nel/misc/types_nl.h" #include "nel/misc/ucstring.h" #include "nel/misc/class_registry.h" #include <utility> #include <string> #include <vector> #include <deque> #include <list> #include <set> #include <map> namespace NLMISC { class IStream; // ====================================================================================================== // ====================================================================================================== // Stream System. // ====================================================================================================== // ====================================================================================================== // For Big/little Endian. # define NLMISC_BSWAP16(src) (src) = (((src)>>8)&0xFF) | (((src)&0xFF)<<8) # ifdef NL_OS_WINDOWS # define NLMISC_BSWAP32(src) _asm mov eax,(src) _asm bswap eax _asm mov (src),eax # else # define NLMISC_BSWAP32(src) (src) = (((src)>>24)&0xFF) | ((((src)>>16)&0xFF)<<8) | ((((src)>>8)&0xFF)<<16) | (((src)&0xFF)<<24) # endif # define NLMISC_BSWAP64(src) (src) = (((src)>>56)&0xFF) | ((((src)>>48)&0xFF)<<8) | ((((src)>>40)&0xFF)<<16) | ((((src)>>32)&0xFF)<<24) | ((((src)>>24)&0xFF)<<32) | ((((src)>>16)&0xFF)<<40) | ((((src)>>8)&0xFF)<<48) | (((src)&0xFF)<<56) // ====================================================================================================== struct EStream : public Exception { EStream() : Exception( "Stream Error" ) {} EStream( const std::string& str ) : Exception( str ) {} EStream( const IStream &f ); EStream( const IStream &f, const std::string& str ); virtual ~EStream() throw() {} // May Not be Filled... std::string StreamName; }; struct EOlderStream : public EStream { EOlderStream() : EStream("The version in stream is older than the class" ) {} EOlderStream(const IStream &f) : EStream(f, "The version in stream is older than the class" ) {} }; struct ENewerStream : public EStream { ENewerStream() : EStream("The version in stream is newer than the class" ) {} ENewerStream(const IStream &f) : EStream(f, "The version in stream is newer than the class" ) {} }; struct EInvalidDataStream : public EStream { EInvalidDataStream() : EStream("Invalid data format" ) {} EInvalidDataStream(const IStream &f) : EStream(f, "Invalid data format" ) {} }; struct ESeekNotSupported : public EStream { ESeekNotSupported() : EStream("Seek fonctionnality is not supported" ) {} ESeekNotSupported(const IStream &f) : EStream(f, "Seek fonctionnality is not supported" ) {} }; class IStreamable; // ====================================================================================================== class IStream { public: static void setVersionException(bool throwOnOlder, bool throwOnNewer); static void getVersionException(bool &throwOnOlder, bool &throwOnNewer); public: explicit IStream(bool inputStream); virtual ~IStream() {} IStream( const IStream& other ); IStream& operator=( const IStream& other ); bool isReading() const; template<class T> void serial(T &obj) { obj.serial(*this); } virtual void serial(uint8 &b) ; virtual void serial(sint8 &b) ; virtual void serial(uint16 &b) ; virtual void serial(sint16 &b) ; virtual void serial(uint32 &b) ; virtual void serial(sint32 &b) ; virtual void serial(uint64 &b) ; virtual void serial(sint64 &b) ; virtual void serial(float &b) ; virtual void serial(double &b) ; virtual void serial(bool &b) ; #ifndef NL_OS_CYGWIN virtual void serial(char &b) ; #endif virtual void serial(std::string &b) ; virtual void serial(ucstring &b) ; template<class T> void serialEnum(T &em) { sint32 i; if(isReading()) { serial(i); em = (T)i; } else { i = em; serial(i); } } uint8 serialBitField8(uint8 bf); uint16 serialBitField16(uint16 bf); uint32 serialBitField32(uint32 bf); template<class T0,class T1> void serial(T0 &a, T1 &b) { serial(a); serial(b);} template<class T0,class T1,class T2> void serial(T0 &a, T1 &b, T2 &c) { serial(a); serial(b); serial(c);} template<class T0,class T1,class T2,class T3> void serial(T0 &a, T1 &b, T2 &c, T3 &d) { serial(a); serial(b); serial(c); serial(d);} template<class T0,class T1,class T2,class T3,class T4> void serial(T0 &a, T1 &b, T2 &c, T3 &d, T4 &e) { serial(a); serial(b); serial(c); serial(d); serial(e);} 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) { serial(a); serial(b); serial(c); serial(d); serial(e); serial(f);} template<class T> void serialCont(std::vector<T> &cont) {serialVector(cont);} template<class T> void serialCont(std::list<T> &cont) {serialSTLCont(cont);} template<class T> void serialCont(std::deque<T> &cont) {serialSTLCont(cont);} template<class T> void serialCont(std::set<T> &cont) {serialSTLCont(cont);} template<class T> void serialCont(std::multiset<T> &cont) {serialSTLCont(cont);} template<class K, class T> void serialCont(std::map<K, T> &cont) {serialMap(cont);} template<class K, class T> void serialCont(std::multimap<K, T> &cont) {serialMultimap(cont);} virtual void serialCont(std::vector<uint8> &cont) ; virtual void serialCont(std::vector<sint8> &cont) ; virtual void serialCont(std::vector<bool> &cont) ; template<class T> void serialContPtr(std::vector<T> &cont) {serialVectorPtr(cont);} template<class T> void serialContPtr(std::list<T> &cont) {serialSTLContPtr(cont);} template<class T> void serialContPtr(std::deque<T> &cont) {serialSTLContPtr(cont);} template<class T> void serialContPtr(std::set<T> &cont) {serialSTLContPtr(cont);} template<class T> void serialContPtr(std::multiset<T> &cont) {serialSTLContPtr(cont);} template<class T> void serialContPolyPtr(std::vector<T> &cont) {serialVectorPolyPtr(cont);} template<class T> void serialContPolyPtr(std::list<T> &cont) {serialSTLContPolyPtr(cont);} template<class T> void serialContPolyPtr(std::deque<T> &cont) {serialSTLContPolyPtr(cont);} template<class T> void serialContPolyPtr(std::set<T> &cont) {serialSTLContPolyPtr(cont);} template<class T> void serialContPolyPtr(std::multiset<T> &cont) {serialSTLContPolyPtr(cont);} template<class T> void serialPtr(T* &ptr) { uint64 node; // Open the node header xmlPushBegin ("PTR"); xmlSetAttrib ("id"); if(isReading()) { serial(node); // Close the header xmlPushEnd (); if(node==0) ptr=NULL; else { ItIdMap it; it= _IdMap.find(node); // Test if object already created/read. if( it==_IdMap.end() ) { // Construct object. ptr= new T; if(ptr==NULL) throw EStream(); // Insert the node. _IdMap.insert( ValueIdMap(node, ptr) ); // Read the object! serial(*ptr); } else ptr= static_cast<T*>(it->second); } } else { if(ptr==NULL) { node= 0; serial(node); // Close the header xmlPushEnd (); } else { node= (uint64)(uint)ptr; serial(node); // Close the header xmlPushEnd (); // Test if object already written. // If the Id was not yet registered (ie insert works). if( _IdMap.insert( ValueIdMap(node, ptr) ).second==true ) { // Write the object! serial(*ptr); } } } // Close the node xmlPop (); } template<class T> void serialPolyPtr(T* &ptr) { IStreamable *p=ptr; serialIStreamable(p); ptr= static_cast<T*>(p);} uint serialVersion(uint currentVersion) ; template<class T> void serialCheck(const T& value) { // Open a node xmlPush ("CHECK"); if (isReading()) { T read; serial (read); if (read!=value) throw EInvalidDataStream(*this); } else { serial (const_cast<T&>(value)); } // Close the node xmlPop (); } enum TSeekOrigin { begin, current, end }; virtual bool seek (sint32 offset, TSeekOrigin origin) ; virtual sint32 getPos () ; virtual std::string getStreamName() const; template<class T> void xmlSerial (T& value0, const char *nodeName) { // Open the node xmlPush (nodeName); // Serial the value serial (value0); // Close the node xmlPop (); } template<class T> void xmlSerial (T& value0, T& value1, const char *nodeName) { // Open the node xmlPush (nodeName); // Serial the values serial (value0, value1); // Close the node xmlPop (); } template<class T> void xmlSerial (T& value0, T& value1, T& value2, const char *nodeName) { // Open the node xmlPush (nodeName); // Serial the values serial (value0, value1, value2); // Close the node xmlPop (); } template<class T> void xmlSerial (T& value0, T& value1, T& value2, T& value3, const char *nodeName) { // Open the node xmlPush (nodeName); // Serial the values serial (value0, value1, value2, value3); // Close the node xmlPop (); } bool xmlPush (const char *name) { // XML Mode ? if (_XML) { // Open the header bool res=xmlPushBeginInternal (name); if (res) // close the header xmlPushEndInternal (); // Return the result return res; } // Return ok return true; } bool xmlPushBegin (const char *name) { // XML Mode ? if (_XML) { return xmlPushBeginInternal (name); } // Return ok return true; } bool xmlPushEnd () { // XML Mode ? if (_XML) { return xmlPushEndInternal (); } // Return ok return true; } bool xmlPop () { // XML Mode ? if (_XML) { return xmlPopInternal (); } // Return ok return true; } bool xmlSetAttrib (const char *name) { // XML Mode ? if (_XML) { return xmlSetAttribInternal (name); } // Return ok return true; } bool xmlBreakLine () { // XML Mode ? if (_XML) { return xmlBreakLineInternal (); } // Return ok return true; } bool xmlComment () { // XML Mode ? if (_XML) { return xmlCommentInternal (); } // Return ok return true; } protected: void setXMLMode (bool on); virtual bool xmlPushBeginInternal (const char *name) { return true; }; virtual bool xmlPushEndInternal () { return true; }; virtual bool xmlPopInternal () { return true; }; virtual bool xmlSetAttribInternal (const char *name) { return true; }; virtual bool xmlBreakLineInternal () { return true; }; virtual bool xmlCommentInternal () { return true; }; void resetPtrTable(); void setInOut(bool inputStream); public: virtual void serialBuffer(uint8 *buf, uint len) =0; virtual void serialBit(bool &bit) =0; virtual void serialBufferWithSize(uint8 *buf, uint32 len) { serial (len); serialBuffer (buf, len); } private: bool _InputStream; static bool _ThrowOnOlder; static bool _ThrowOnNewer; // Ptr registry. We store 64 bit Id, to be compatible with futur 64+ bits pointers. std::map<uint64, void*> _IdMap; typedef std::map<uint64, void*>::iterator ItIdMap; typedef std::map<uint64, void*>::value_type ValueIdMap; // Ptr serialisation. void serialIStreamable(IStreamable* &ptr) ; private: template<class T> void serialSTLContLen(T &cont, sint32 len) { typedef typename T::value_type __value_type; typedef typename T::iterator __iterator; if(isReading()) { for(sint i=0;i<len;i++) { xmlPush ("ELM"); __value_type v; serial(v); (void)cont.insert(cont.end(), v); xmlPop (); } } else { __iterator it= cont.begin(); for(sint i=0;i<len;i++, it++) { xmlPush ("ELM"); serial(const_cast<__value_type&>(*it)); xmlPop (); } } } template<class T> void serialSTLCont(T &cont) { // Open a node header xmlPushBegin ("CONTAINER"); // Attrib size xmlSetAttrib ("size"); sint32 len=0; if(isReading()) { serial(len); cont.clear(); } else { len= cont.size(); serial(len); } // Close the header xmlPushEnd (); serialSTLContLen(cont, len); // Close the node xmlPop (); } protected: template<class T> void serialVector(T &cont) { typedef typename T::value_type __value_type; typedef typename T::iterator __iterator; // Open a node header xmlPushBegin ("VECTOR"); // Attrib size xmlSetAttrib ("size"); sint32 len=0; if(isReading()) { serial(len); // Open a node header xmlPushEnd (); // special version for vector: adjut good size. contReset(cont); cont.resize (len); // Read the vector for(sint i=0;i<len;i++) { xmlPush ("ELM"); serial(cont[i]); xmlPop (); } } else { len= cont.size(); serial(len); // Close the node header xmlPushEnd (); // Write the vector __iterator it= cont.begin(); for(sint i=0;i<len;i++, it++) { xmlPush ("ELM"); serial(const_cast<__value_type&>(*it)); xmlPop (); } } // Close the node xmlPop (); } private: template<class T> void serialSTLContLenPtr(T &cont, sint32 len) { typedef typename T::value_type __value_type; typedef typename T::iterator __iterator; if(isReading()) { for(sint i=0;i<len;i++) { __value_type v; serialPtr(v); cont.insert(cont.end(), v); } } else { __iterator it= cont.begin(); for(sint i=0;i<len;i++, it++) { serialPtr(const_cast<__value_type&>(*it)); } } } template<class T> void serialSTLContPtr(T &cont) { // Open a node header xmlPushBegin ("CONTAINER"); // Attrib size xmlSetAttrib ("size"); sint32 len=0; if(isReading()) { serial(len); cont.clear(); } else { len= cont.size(); serial(len); } // Close the node header xmlPushEnd (); serialSTLContLenPtr(cont, len); // Close the node xmlPop (); } template<class T> void serialVectorPtr(T &cont) { typedef typename T::value_type __value_type; typedef typename T::iterator __iterator; // Open a node header xmlPushBegin ("VECTOR"); // Attrib size xmlSetAttrib ("size"); sint32 len=0; if(isReading()) { serial(len); // special version for vector: adjut good size. contReset(cont); cont.reserve(len); } else { len= cont.size(); serial(len); } // Close the node header xmlPushEnd (); serialSTLContLenPtr(cont, len); // Close the node xmlPop (); } private: template<class T> void serialSTLContLenPolyPtr(T &cont, sint32 len) { typedef typename T::value_type __value_type; typedef typename T::iterator __iterator; if(isReading()) { for(sint i=0;i<len;i++) { __value_type v=NULL; serialPolyPtr(v); cont.insert(cont.end(), v); } } else { __iterator it= cont.begin(); for(sint i=0;i<len;i++, it++) { serialPolyPtr(const_cast<__value_type&>(*it)); } } } template<class T> void serialSTLContPolyPtr(T &cont) { sint32 len=0; if(isReading()) { serial(len); cont.clear(); } else { len= cont.size(); serial(len); } serialSTLContLenPolyPtr(cont, len); } template<class T> void serialVectorPolyPtr(T &cont) { typedef typename T::value_type __value_type; typedef typename T::iterator __iterator; // Open a node header xmlPushBegin ("VECTOR"); // Attrib size xmlSetAttrib ("size"); sint32 len=0; if(isReading()) { serial(len); // special version for vector: adjut good size. contReset(cont); cont.reserve(len); } else { len= cont.size(); serial(len); } // Close the node header xmlPushEnd (); serialSTLContLenPolyPtr(cont, len); // Close the node xmlPop (); } private: template<class T> void serialMultimap(T &cont) { typedef typename T::value_type __value_type; typedef typename T::key_type __key_type; typedef typename T::iterator __iterator; // Open a node header xmlPushBegin ("MULTIMAP"); // Attrib size xmlSetAttrib ("size"); sint32 len; if(isReading()) { cont.clear(); serial(len); // Close the node header xmlPushEnd (); for(sint i=0;i<len;i++) { __value_type v; xmlPush ("KEY"); serial ( const_cast<__key_type&>(v.first) ); xmlPop (); xmlPush ("ELM"); serial (v.second); xmlPop (); cont.insert(cont.end(), v); } } else { len= cont.size(); serial(len); __iterator it= cont.begin(); // Close the node header xmlPushEnd (); for(sint i=0;i<len;i++, it++) { xmlPush ("KEY"); serial( const_cast<__key_type&>((*it).first) ); xmlPop (); xmlPush ("ELM"); serial((*it).second); xmlPop (); } } // Close the node xmlPop (); } template<class T> void serialMap(T &cont) { typedef typename T::value_type __value_type; typedef typename T::key_type __key_type; typedef typename T::iterator __iterator; // Open a node header xmlPushBegin ("MAP"); // Attrib size xmlSetAttrib ("size"); sint32 len; if(isReading()) { cont.clear(); serial(len); // Close the node header xmlPushEnd (); for(sint i=0;i<len;i++) { /* __value_type v; xmlPush ("KEY"); serial ( const_cast<__key_type&>(v.first) ); xmlPop (); xmlPush ("ELM"); serial (v.second); xmlPop (); cont.insert(cont.end(), v); */ // MALKAV 05/07/02 : prevent a copy of the value, copy the key instead __key_type k; xmlPush ("KEY"); serial ( k ); xmlPop (); xmlPush ("ELM"); serial (cont[k]); xmlPop (); } } else { len= cont.size(); serial(len); __iterator it= cont.begin(); // Close the node header xmlPushEnd (); for(sint i=0;i<len;i++, it++) { xmlPush ("KEY"); serial( const_cast<__key_type&>((*it).first) ); xmlPop (); xmlPush ("ELM"); serial((*it).second); xmlPop (); } } // Close the node xmlPop (); } // Mode XML bool _XML; }; // ====================================================================================================== // ====================================================================================================== // Handle for streaming Polymorphic classes. // ====================================================================================================== // ====================================================================================================== // ====================================================================================================== class IStreamable : public IClassable { public: virtual void serial(IStream &f) =0; }; } // NLMISC. // Inline Implementation. #include "nel/misc/stream_inline.h" #endif // NL_STREAM_H /* End of stream.h */