CWE-ou-minkata/Sources/Tools/plDatMerger/plRawPageAccessor.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.
//
//  Also assumes the current global resManager is a plRawResManager!
//
//////////////////////////////////////////////////////////////////////////////

#include "hsTypes.h"
#include "hsStream.h"
#include "plRawPageAccessor.h"
#include "plRawResManager.h"
#include "plRawKeyedObject.h"

#include "hsTemplates.h"
#include "../pnKeyedObject/plKeyImp.h"
#include "../plResMgr/plRegistryNode.h"
#include "../plResMgr/plRegistryHelpers.h"
#include "../plResMgr/plRegistrySource.h"


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

plRawPageAccessor::plRawPageAccessor( plRegistryPageNode *source, hsBool read )
{
    fSource = source;
    if( read )
        ReadFromSource();
}

plRawPageAccessor::~plRawPageAccessor()
{
    Release();
}

//// Iterators ///////////////////////////////////////////////////////////////

class plRawReaderIter : public plRegistryKeyIterator
{
    public:

        virtual hsBool  EatKey( plKey key )
        {
            plRawResManager *mgr = (plRawResManager *)hsgResMgr::ResMgr();

            UInt32 len;
            plKeyImp *imp = (plKeyImp *)key;
            UInt8 *buffer = mgr->ReadObjectBuffer( imp, len );

            // This will also set the object ptr in the key
            plRawKeyedObject *obj = new plRawKeyedObject( key, len, buffer );
            delete [] buffer;       // rawKeyedObject keeps a copy

            return true;
        }
};

class plRawWriterIter : public plRegistryKeyIterator
{
    hsStream    *fStream;

    public:

        plRawWriterIter( hsStream *stream ) : fStream( stream ) {}

        virtual hsBool  EatKey( plKey key )
        {
            plRawResManager *mgr = (plRawResManager *)hsgResMgr::ResMgr();

            plRawKeyedObject *obj = (plRawKeyedObject *)key->ObjectIsLoaded();
            if( obj == nil )
            {
                // Mark the key as not written
                plRawKeyedObject::MarkAsEmpty( key );
                return true;
            }

            obj->Write( fStream );
            return true;
        }
};

class plRawReleaseIter : public plRegistryKeyIterator
{
    public:

        virtual hsBool  EatKey( plKey key )
        {
            plRawKeyedObject *obj = (plRawKeyedObject *)key->ObjectIsLoaded();
            delete obj;

            return true;
        }
};


//// Various Functions ///////////////////////////////////////////////////////

void    plRawPageAccessor::ReadFromSource( void )
{
    if( !fSource->IsLoaded() )
        fSource->LoadKeysFromSource();

    plRawReaderIter iter;
    fSource->IterateKeys( &iter );
}

void    plRawPageAccessor::WriteToSource( void )
{
    if( fSource->GetSource() == nil )
    {
        hsAssert( false, "Unable to write accessor to disk; no source defined!" );
        return;
    }

    // Write out objects first
    hsStream *stream = fSource->GetSource()->OpenDataStream( fSource, true );
    if( stream == nil )
        return;

    plRawWriterIter writer( stream );
    fSource->IterateKeys( &writer );

    fSource->GetSource()->CloseDataStream( fSource );
    
    // Now write out the keys
    fSource->WriteKeysToSource();
}

void    plRawPageAccessor::Release( void )
{
    plRawReleaseIter    iter;
    fSource->IterateKeys( &iter );

    fSource->ClearKeyLists();
}

void    plRawPageAccessor::AddCopy( const plKey &origKey )
{
    plRawResManager *mgr = (plRawResManager *)hsgResMgr::ResMgr();
    plKey           newKey;


    // Get the source object
    plRawKeyedObject *srcObj = (plRawKeyedObject *)origKey->ObjectIsLoaded();

    // Construct a new uoid
    plUoid          newUoid( fSource->GetPageInfo().GetLocation(), 
                             origKey->GetUoid().GetClassType(), 
                             origKey->GetUoid().GetObjectName() );

    // Does it already exist?
    newKey = mgr->FindKey( newUoid );
    if( newKey != nil )
    {
        // Yup, gotta get rid of old object (if there is one)
        plRawKeyedObject *obj = (plRawKeyedObject *)newKey->ObjectIsLoaded();
        delete obj;
    }
    else
    {
        // Nope, gotta create key first
        newKey = mgr->NewBlankKey( newUoid );
    }

    // Force the key's uoid to the right uoid, now that it's in the right page
    ( (plKeyImp *)newKey )->SetUoid( origKey->GetUoid() );

    // Assign a new buffer to the key
    if( srcObj != nil )
    {
        // Will set obj pointer in key
        plRawKeyedObject *obj = new plRawKeyedObject( newKey, srcObj->GetBufferSize(), srcObj->GetBuffer() );
    }
}

void    plRawPageAccessor::UpdateDataVersion( plRegistryPageNode *from )
{
    plPageInfo &orig = from->GetPageInfo();

    fSource->GetPageInfo().SetVersion( orig.GetMajorVersion(), orig.GetMinorVersion() );
    fSource->GetPageInfo().SetReleaseVersion( orig.GetReleaseVersion() );
}