Database Structure

#ifndef _DYNMEMSTREAM_H_

#define _DYNMEMSTREAM_H_

#ifndef _MEMSTREAM_H_

#include "core/memstream.h"

#endif

class DynMemStream : public MemStream {

	typedef MemStream Parent;

	

	protected:

		U32 m_blockSize;	///< Chunk size for new allocations

		U32 m_writSize;	///< Bytes we have written

	

	public:

		DynMemStream(const U32  in_blockSize,

						const bool in_allowRead  = true,

						const bool in_allowWrite = true);

		~DynMemStream();



		U32 getStreamSize() {return m_writSize;}

		char *getData() {return (char*)m_pBufferBase;}

	protected:

		bool _write(const U32 in_numBytes, const void* in_pBuffer);

};

#endif //_DYNMEMSTREAM_H_

//Includes
#include "platform/platform.h"

#include "streams/dynamicMemStream.h"

DynMemStream::DynMemStream(const U32 in_blockSize,

                     const bool   in_allowRead,

                     const bool   in_allowWrite)

{

   m_blockSize = in_blockSize;

   m_instCaps = 0;

   m_currentPosition = 0;

   m_writSize = 0;

   AssertFatal(in_blockSize > 0,  "Invalid block size");

   AssertFatal(in_allowRead || in_allowWrite, "Either write or read must be allowed");



   char *data = (char*)dMalloc(in_blockSize);

   cm_bufferSize = in_blockSize;

   m_pBufferBase = (void*)data;



   if (in_allowRead)

      m_instCaps |= Stream::StreamRead;

   if (in_allowWrite)

      m_instCaps |= Stream::StreamWrite;



   setStatus(Ok);

}



DynMemStream::~DynMemStream()

{

	dFree(m_pBufferBase);

}



bool DynMemStream::_write(const U32 in_numBytes, const void *in_pBuffer)

{

   AssertFatal(getStatus() != Closed, "Attempted write to a closed stream");



   if (in_numBytes == 0)

      return true;



   AssertFatal(in_pBuffer != NULL, "Invalid input buffer");



   if (hasCapability(StreamWrite) == false) {

      AssertWarn(0, "Writing is disallowed on this stream");

      setStatus(IllegalCall);

      return false;

   }



   bool success     = true;

   if ((m_currentPosition + in_numBytes) > cm_bufferSize) {

      // TODO: could be a bit more accurate...

      U32 newSize = (((m_currentPosition + in_numBytes) - cm_bufferSize) / m_blockSize)+1;

      newSize *= m_blockSize;

      m_pBufferBase = dRealloc((char*)m_pBufferBase, newSize);

      AssertFatal(m_pBufferBase, "Failed to reallocate buffer!");

      cm_bufferSize = newSize;

   }



   // Obtain a current pointer, and do the copy

   void* pCurrent = (void*)((char*)m_pBufferBase + m_currentPosition);

   dMemcpy(pCurrent, in_pBuffer, in_numBytes);



   // Advance the stream position

   m_currentPosition += in_numBytes;

   if (m_currentPosition > m_writSize)

      m_writSize += in_numBytes;



   if (m_currentPosition == cm_bufferSize)

      setStatus(EOS);

   else

      setStatus(Ok);



   return success;

}

// save to string
ConsoleMethod(SimObject, saveToString, const char*, 2, 3, "obj.save(<selectedOnly>)")
{
	static const char *beginMessage = "//--- OBJECT WRITE BEGIN ---";
	8static const char *endMessage = "//--- OBJECT WRITE END ---";
	

        DynMemStream stream(4096, false, true);
	
	// check for flags <selected, ...>
	U32 writeFlags = 0;
	if(argc > 3)
	{
		if(dAtob(argv[3]))
			writeFlags |= SimObject::SelectedOnly;
	}
	
	// Write the begin message
	stream.write(dStrlen(beginMessage), beginMessage);
	stream.write(2, "\r\n");
	
	// Write the object's serialization into the stream
	object->write(stream, 0, writeFlags);
	
	// Write the end message
	stream.write(dStrlen(endMessage), endMessage);
	stream.write(2, "\r\n");

        char *ret = Con::getReturnBuffer(stream.getStreamSize() + 1);

        dStrncpy(ret, stream.getData(), stream.getStreamSize());

        ret[stream.getStreamSize()] = 0;

        return ret;
   
}
// end save to string