CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Tools/plDatMerger/plRawKeyedObject.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program 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 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//////////////////////////////////////////////////////////////////////////////
//
//	plRawPageAccessor - Dangerous little class that lets you take a
//					    plRegistryPageNode and load the objects in raw (i.e.
//						as block memory buffers).
//						This should NOT be used in any normal app, only 
//						utility apps that don't want to load objects in
//						normally (which basically means if you're not mcn,
//						don't use this!)
//
//// Why We're Bad ///////////////////////////////////////////////////////////
//
//	To store all the raw buffers, we stuff them as pointers into the keys
//	themselves. This is Way Bad(tm) because those pointers are expecting
//	hsKeyedObjects, and what we're giving them certainly ain't those.
//	This is why it's only safe to use this class in a very small, controlled
//	environment, one where we know the keys won't be accessed in a normal
//	fashion so we know nobody will try to use our pointers in a bad way.
//
//////////////////////////////////////////////////////////////////////////////

#include "hsTypes.h"
#include "hsStream.h"
#include "hsResMgr.h"
#include "plRawKeyedObject.h"
#include "../pnKeyedObject/plKeyImp.h"


//// Tiny Yet Now Famous Key Hack ////////////////////////////////////////////

class plPublicKeyImp : public plKeyImp
{
	public:

		void	SetObjectPtrDirect( hsKeyedObject *obj ) 
		{
			fObjectPtr = obj;
		}

		void	SetAsEmpty( void )
		{
			fStartPos = (UInt32)-1;
			fDataLen = (UInt32)-1;
		}

		void	SetStartPosFromStream( hsStream *stream )
		{
			fStartPos = stream->GetPosition();
		}

		void	SetLengthFromStream( hsStream *stream ) 
		{ 
			fDataLen = stream->GetPosition() - fStartPos;
		}
};

//// Constructor/Destructor //////////////////////////////////////////////////

plRawKeyedObject::plRawKeyedObject()
{
	fSrcKey = nil;
	fBuffer = nil;
	fBufferSize = 0;
}

plRawKeyedObject::plRawKeyedObject( const plKey &key, UInt32 size, UInt8 *data )
{
	fSrcKey = key;
	( (plPublicKeyImp *)(plKeyImp *)key )->SetObjectPtrDirect( this );

	fBuffer = nil;
	fBufferSize = 0;

	SetBuffer( size, data );
}

plRawKeyedObject::~plRawKeyedObject()
{
	if( fSrcKey != nil )
	{
		( (plPublicKeyImp *)(plKeyImp *)fSrcKey )->SetObjectPtrDirect( nil );
		fSrcKey = nil;
	}

	delete [] fBuffer;
}

void	plRawKeyedObject::SetBuffer( UInt32 size, UInt8 *data )
{
	delete [] fBuffer;

	if( data == nil )
	{
		fBufferSize = 0;
		fBuffer = nil;
		return;
	}

	fBufferSize = size;
	fBuffer = new UInt8[ size ];
	memcpy( fBuffer, data, size );
}

void	plRawKeyedObject::SetKey( plKey k )
{
	if( fSrcKey != nil )
	{
		( (plPublicKeyImp *)(plKeyImp *)fSrcKey )->SetObjectPtrDirect( nil );
	}

	fSrcKey = k;
	if( fSrcKey != nil )
	{
		( (plPublicKeyImp *)(plKeyImp *)fSrcKey )->SetObjectPtrDirect( this );
	}
}

void	plRawKeyedObject::MarkAsEmpty( plKey &key )
{
	( (plPublicKeyImp *)(plKeyImp *)key )->SetAsEmpty();
}

void	plRawKeyedObject::Write( hsStream *stream )
{
	// BEFORE we write out, somewhere at the top of our buffer is the key to ourselves
	// that all hsKeyedObjects write out as part of their Write() function. We need
	// to REPLACE that key with our new key, since our location has now changed. Note
	// that this will ONLY work if our location changes, NOT if our name changes, 
	// because we're relying on the fact that the written size of our key is not
	// going to change!!!
	{
		hsWriteOnlyStream	replaceStream( fBufferSize, fBuffer );

		// Here's the part that REALLY sucks, 'cause it assumes our written format will never change!!!!
		// It ALSO assumes, VERY dangerously, that ReadSwap16() will ALWAYS read a size UInt16

		replaceStream.SetPosition( sizeof( UInt16 ) );	// Get past creatable class that resManager writes out

		hsgResMgr::ResMgr()->WriteKey( &replaceStream, fSrcKey, hsResMgr::kWriteNoCheck );
	}

	( (plPublicKeyImp *)(plKeyImp *)fSrcKey )->SetStartPosFromStream( stream );

	stream->Write( fBufferSize, fBuffer );

	( (plPublicKeyImp *)(plKeyImp *)fSrcKey )->SetLengthFromStream( stream );
}


//// Warning Stubs ///////////////////////////////////////////////////////////

void	plRawKeyedObject::Validate()
{
	hsAssert( false, "Invalid call on plRawKeyedObject" );
}

hsBool	plRawKeyedObject::IsFinal()
{
	hsAssert( false, "Invalid call on plRawKeyedObject" );
	return false;
}

void	plRawKeyedObject::Read(hsStream *s, hsResMgr *mgr )
{
	hsAssert( false, "Invalid call on plRawKeyedObject" );
}

void	plRawKeyedObject::Write(hsStream *s, hsResMgr *mgr )
{
	hsAssert( false, "Invalid call on plRawKeyedObject" );
}

hsBool	plRawKeyedObject::MsgReceive( plMessage *msg )
{
	hsAssert( false, "Invalid call on plRawKeyedObject" );
	return false;
}

hsKeyedObject *plRawKeyedObject::GetSharedObject()
{
	hsAssert( false, "Invalid call on plRawKeyedObject" );
	return nil;
}