mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-12-14 05:44:52 +00:00
484 lines
11 KiB
C++
484 lines
11 KiB
C++
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program 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 Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#include "stdmisc.h"
|
|
|
|
#include "nel/misc/stream.h"
|
|
#include "nel/misc/mem_stream.h"
|
|
|
|
using namespace std;
|
|
|
|
|
|
namespace NLMISC
|
|
{
|
|
|
|
|
|
// ======================================================================================================
|
|
// ======================================================================================================
|
|
// EStream.
|
|
// ======================================================================================================
|
|
// ======================================================================================================
|
|
|
|
|
|
// ======================================================================================================
|
|
EStream::EStream( const IStream &f ) : Exception( "In Stream: " + f.getStreamName() + string(": Stream Error") )
|
|
{
|
|
StreamName= f.getStreamName();
|
|
}
|
|
|
|
EStream::EStream( const IStream &f, const std::string& str )
|
|
: Exception( "In Stream: " + f.getStreamName() + ": " + str )
|
|
{
|
|
StreamName= f.getStreamName();
|
|
}
|
|
|
|
EInvalidDataStream::EInvalidDataStream(const char *msg, uint size)
|
|
: EStream( NLMISC::toString( msg, size ) )
|
|
{}
|
|
|
|
|
|
EStreamOverflow::EStreamOverflow( const char *msg, uint size )
|
|
: EStream( NLMISC::toString( msg, size ) )
|
|
{}
|
|
|
|
|
|
// ======================================================================================================
|
|
// ======================================================================================================
|
|
// IStream.
|
|
// ======================================================================================================
|
|
// ======================================================================================================
|
|
|
|
|
|
// ======================================================================================================
|
|
bool IStream::_ThrowOnOlder=false;
|
|
bool IStream::_ThrowOnNewer=true;
|
|
|
|
|
|
// ======================================================================================================
|
|
void IStream::setVersionException(bool throwOnOlder, bool throwOnNewer)
|
|
{
|
|
_ThrowOnOlder=throwOnOlder;
|
|
_ThrowOnNewer=throwOnNewer;
|
|
}
|
|
|
|
// ======================================================================================================
|
|
void IStream::getVersionException(bool &throwOnOlder, bool &throwOnNewer)
|
|
{
|
|
throwOnOlder=_ThrowOnOlder;
|
|
throwOnNewer=_ThrowOnNewer;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Copy constructor
|
|
*/
|
|
IStream::IStream( const IStream& other )
|
|
{
|
|
operator=( other );
|
|
|
|
// By default, mode _XML is off
|
|
_XML = false;
|
|
}
|
|
|
|
|
|
/*
|
|
* Assignment operator
|
|
*/
|
|
IStream& IStream::operator=( const IStream& other )
|
|
{
|
|
_InputStream = other._InputStream;
|
|
resetPtrTable();
|
|
return *this;
|
|
}
|
|
|
|
void IStream::swap(IStream &other)
|
|
{
|
|
std::swap(_InputStream, other._InputStream);
|
|
std::swap(_NextSerialPtrId, other._NextSerialPtrId);
|
|
_IdMap.swap(other._IdMap);
|
|
std::swap(_XML, other._XML);
|
|
}
|
|
|
|
|
|
// ======================================================================================================
|
|
// ======================================================================================================
|
|
// ======================================================================================================
|
|
|
|
|
|
// ======================================================================================================
|
|
void IStream::serialIStreamable(IStreamable* &ptr)
|
|
{
|
|
uint64 node=0;
|
|
|
|
// Open a node
|
|
xmlPushBegin ("POLYPTR");
|
|
|
|
if(isReading())
|
|
{
|
|
// First attribute name
|
|
xmlSetAttrib ("id");
|
|
|
|
serial(node);
|
|
|
|
if(node==0)
|
|
{
|
|
ptr=NULL;
|
|
|
|
// Close the node header
|
|
xmlPushEnd ();
|
|
}
|
|
else
|
|
{
|
|
ItIdMap it;
|
|
it= _IdMap.find(node);
|
|
|
|
// Test if object already created/read.
|
|
if( it==_IdMap.end() )
|
|
{
|
|
// Read the class name.
|
|
string className;
|
|
|
|
// Second attribute name
|
|
xmlSetAttrib ("class");
|
|
|
|
serial(className);
|
|
|
|
// Close the node header
|
|
xmlPushEnd ();
|
|
|
|
// Construct object.
|
|
ptr= dynamic_cast<IStreamable*> (CClassRegistry::create(className));
|
|
if(ptr==NULL)
|
|
#ifdef NL_DEBUG
|
|
throw EUnregisteredClass(className);
|
|
#else
|
|
throw EUnregisteredClass();
|
|
#endif
|
|
|
|
|
|
#ifdef NL_DEBUG
|
|
nlassert(CClassRegistry::checkObject(ptr));
|
|
#endif
|
|
|
|
// Insert the node.
|
|
_IdMap.insert( ValueIdMap(node, ptr) );
|
|
|
|
// Read the object!
|
|
ptr->serial(*this);
|
|
}
|
|
else
|
|
{
|
|
ptr= static_cast<IStreamable*>(it->second);
|
|
|
|
// Close the node header
|
|
xmlPushEnd ();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(ptr==NULL)
|
|
{
|
|
node= 0;
|
|
|
|
// First attribute name
|
|
xmlSetAttrib ("id");
|
|
|
|
serial(node);
|
|
|
|
// Close the node header
|
|
xmlPushEnd ();
|
|
}
|
|
else
|
|
{
|
|
// Assume that prt size is an int size
|
|
//#ifdef NL_DEBUG
|
|
// nlassert(sizeof(uint) == sizeof(void *));
|
|
//#endif
|
|
|
|
ItIdMap it;
|
|
it = _IdMap.find((uint64)/*(uint)*/ptr);
|
|
|
|
// Test if object has been already written
|
|
if( it==_IdMap.end() )
|
|
{
|
|
// Not yet written
|
|
|
|
// Get the next available ID
|
|
node = _NextSerialPtrId++;
|
|
|
|
// Serial the id
|
|
xmlSetAttrib ("id");
|
|
serial(node);
|
|
|
|
// Insert the pointer in the map with the id
|
|
_IdMap.insert( ValueIdMap((uint64)/*(uint)*/ptr, (void*)/*(uint)*/node) );
|
|
|
|
#ifdef NL_DEBUG
|
|
nlassert(CClassRegistry::checkObject(ptr));
|
|
#endif
|
|
|
|
// Write the class name.
|
|
string className=ptr->getClassName();
|
|
|
|
// Second attribute name
|
|
xmlSetAttrib ("class");
|
|
serial(className);
|
|
|
|
// Close the node header
|
|
xmlPushEnd ();
|
|
|
|
// Write the object!
|
|
ptr->serial(*this);
|
|
}
|
|
else
|
|
{
|
|
// Write only the object id
|
|
xmlSetAttrib ("id");
|
|
node = (uint64)/*(uint)*/(it->second);
|
|
serial(node);
|
|
xmlPushEnd ();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Close the node
|
|
xmlPop ();
|
|
}
|
|
// ======================================================================================================
|
|
void IStream::resetPtrTable()
|
|
{
|
|
_IdMap.clear();
|
|
_NextSerialPtrId = 1; // Start at 1 because 0 is the NULL pointer
|
|
}
|
|
|
|
|
|
// ======================================================================================================
|
|
// ======================================================================================================
|
|
// ======================================================================================================
|
|
|
|
|
|
// ======================================================================================================
|
|
uint IStream::serialVersion(uint currentVersion)
|
|
{
|
|
uint8 b=0;
|
|
uint32 v=0;
|
|
uint streamVersion;
|
|
|
|
// Open the node
|
|
xmlPush ("VERSION");
|
|
|
|
if(isReading())
|
|
{
|
|
serial(b);
|
|
if(b==0xFF)
|
|
serial(v);
|
|
else
|
|
v=b;
|
|
streamVersion=v;
|
|
|
|
// Exception test.
|
|
if(_ThrowOnOlder && streamVersion < currentVersion)
|
|
throw EOlderStream(*this);
|
|
if(_ThrowOnNewer && streamVersion > currentVersion)
|
|
throw ENewerStream(*this);
|
|
}
|
|
else
|
|
{
|
|
v= streamVersion=currentVersion;
|
|
if(v>=0xFF)
|
|
{
|
|
b=0xFF;
|
|
serial(b);
|
|
serial(v);
|
|
}
|
|
else
|
|
{
|
|
b= (uint8)v;
|
|
serial(b);
|
|
}
|
|
}
|
|
|
|
// Close the node
|
|
xmlPop ();
|
|
|
|
return streamVersion;
|
|
}
|
|
|
|
|
|
// ======================================================================================================
|
|
// ======================================================================================================
|
|
// ======================================================================================================
|
|
|
|
// ======================================================================================================
|
|
void IStream::serialCont(vector<uint8> &cont)
|
|
{
|
|
sint32 len=0;
|
|
if(isReading())
|
|
{
|
|
serial(len);
|
|
|
|
// check stream holds enough bytes (avoid STL to crash on resize)
|
|
checkStreamSize(len);
|
|
|
|
// one block serial
|
|
cont.resize(len);
|
|
if (len != 0)
|
|
serialBuffer( (uint8*)&(*cont.begin()) , len);
|
|
}
|
|
else
|
|
{
|
|
len= (sint32)cont.size();
|
|
serial(len);
|
|
if (len != 0)
|
|
serialBuffer( (uint8*)&(*cont.begin()) , len);
|
|
}
|
|
}
|
|
// ======================================================================================================
|
|
void IStream::serialCont(vector<sint8> &cont)
|
|
{
|
|
sint32 len=0;
|
|
if(isReading())
|
|
{
|
|
serial(len);
|
|
|
|
// check stream holds enough bytes (avoid STL to crash on resize)
|
|
checkStreamSize(len);
|
|
|
|
// one block serial
|
|
cont.resize(len);
|
|
if (len != 0)
|
|
serialBuffer( (uint8*)&(*cont.begin()) , len);
|
|
}
|
|
else
|
|
{
|
|
len= (sint32)cont.size();
|
|
serial(len);
|
|
if (len != 0)
|
|
serialBuffer( (uint8*)&(*cont.begin()) , len);
|
|
}
|
|
}
|
|
// ======================================================================================================
|
|
void IStream::serialCont(vector<bool> &cont)
|
|
{
|
|
sint32 len=0;
|
|
vector<uint8> vec;
|
|
|
|
if(isReading())
|
|
{
|
|
serial(len);
|
|
|
|
// check stream holds enough bytes (avoid STL to crash on resize)
|
|
checkStreamSize(len/8);
|
|
|
|
// One Block Serial
|
|
cont.resize(len);
|
|
|
|
if (len != 0)
|
|
{
|
|
// read as uint8*.
|
|
sint lb= (len+7)/8;
|
|
vec.resize(lb);
|
|
serialBuffer( (uint8*)&(*vec.begin()) , lb);
|
|
for(sint i=0;i<len;i++)
|
|
{
|
|
uint bit= (vec[i>>3]>>(i&7)) & 1;
|
|
cont[i]= bit?true:false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
len= (sint32)cont.size();
|
|
serial(len);
|
|
|
|
if (len != 0)
|
|
{
|
|
// write as uint8*.
|
|
sint lb= (len+7)/8;
|
|
vec.resize(lb);
|
|
fill_n(vec.begin(), lb, 0);
|
|
for(sint i=0;i<len;i++)
|
|
{
|
|
uint bit= cont[i]?1:0;
|
|
vec[i>>3]|= bit<<(i&7);
|
|
}
|
|
serialBuffer( (uint8*)&(*vec.begin()) , lb);
|
|
}
|
|
}
|
|
|
|
}
|
|
// ======================================================================================================
|
|
bool IStream::seek (sint32 offset, TSeekOrigin origin) const
|
|
{
|
|
throw ESeekNotSupported(*this);
|
|
}
|
|
// ======================================================================================================
|
|
sint32 IStream::getPos () const
|
|
{
|
|
throw ESeekNotSupported(*this);
|
|
}
|
|
|
|
// ======================================================================================================
|
|
void IStream::setInOut(bool inputStream)
|
|
{
|
|
_InputStream= inputStream;
|
|
}
|
|
|
|
|
|
// ======================================================================================================
|
|
string IStream::getStreamName() const
|
|
{
|
|
return "";
|
|
}
|
|
|
|
|
|
// ======================================================================================================
|
|
void IStream::setXMLMode (bool on)
|
|
{
|
|
_XML = on;
|
|
}
|
|
|
|
|
|
/*
|
|
* Serial memstream, bitmemstream...
|
|
*/
|
|
void IStream::serialMemStream( CMemStream &b )
|
|
{
|
|
uint32 len=0;
|
|
|
|
// Serialize length
|
|
if ( isReading() )
|
|
{
|
|
// fill b with data from this
|
|
serial (len);
|
|
serialBuffer (b.bufferToFill (len), len);
|
|
b.resetBufPos ();
|
|
}
|
|
else
|
|
{
|
|
// fill this with data from b
|
|
len = b.length();
|
|
|
|
serial( len );
|
|
serialBuffer( (uint8*) b.buffer (), len );
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|