MercuryObjectFactory.cpp

Go to the documentation of this file.

#include "MercuryObjectFactory.h"
#include "MercuryLog.h"
#include "MercuryUtil.h"

MercuryObjectFactory& MercuryObjectFactory::GetInstance()
{
    static MercuryObjectFactory* instance = NULL;
    if (!instance)
        instance = new MercuryObjectFactory;
    return *instance;
}

PSElement ObjectCallFail( MercuryCommandHandler * pThs, const PStack & pParameters )
{
    return PSElement();
}

bool MercuryObjectFactory::RegisterObjectClass( const MString & sClassName, MakeObjectCommand pCmd )
{
    m_mClasses[sClassName] = pCmd;
    return true;
}

MercuryObject * MercuryObjectFactory::GenerateObject( const MString & sClass, const MString & sName )
{
    if ( !m_mClasses.get( sClass ) )
        return NULL;
    return m_mClasses[sClass]( sName );
}

void MercuryObjectFactory::FinalizeCallbacks()
{
    MVector< MString > vClasses;
    m_mClasses.VectorIndicies( vClasses );
    for( unsigned i = 0; i < vClasses.size(); i++ )
    {
        MString sName = vClasses[i];
        MVector< MString > vTypes;
        MercuryCommandHandler * pObject = m_mClasses[sName]( "Dummy" + sName );
        pObject->GetAllTypes( vTypes );

        //vTypes is now a list, with the topmost inherited item on top, and the base on the bottom
        //for this reason we go through from the back front, ensuring that overridden items
        //take precidence.

        for( int i = vTypes.size()-1; i >= 0 ; i-- )
        {
            MVector< MString > vCmds;
            MString TYPE = vTypes[i];
            MHash< ClassCallback * > * G = m_mPreCallbacks.get(TYPE);
            if( !G ) 
                continue;
            G->VectorIndicies( vCmds );
            
            for( unsigned cmds = 0; cmds < vCmds.size(); cmds++ )
            {
                MString CMD = vCmds[cmds];
                void * TMP = G->get(CMD);
                if( TMP )
                    m_mFinalCallbacks[sName][CMD] = (*G)[CMD];
            }
        }
        m_vTemplateObjects.push_back( (MercuryObject*)pObject );
    }
}

void MercuryObjectFactory::RegisterFunction( ClassCallback * pCallback, const MString & sClassName, const MString & sCallbackName )
{
    m_mPreCallbacks[sClassName][sCallbackName] = pCallback;
}

ClassCallback * MercuryObjectFactory::GetCallback( const MString & sClassName, const MString & sFunctionName )
{
    if( !m_mFinalCallbacks.get( sClassName ) )
    {
        LOG.Warn( "Call attempt: " + sClassName + "::" + sFunctionName + " failed. No such class type." );
        return &ObjectCallFail;
    }

    if( !m_mFinalCallbacks[sClassName].get( sFunctionName ) )
    {
        LOG.Warn( "Call attempt: " + sClassName + "::" + sFunctionName + " failed. No such function name." );
        return &ObjectCallFail;
    }

    return m_mFinalCallbacks[sClassName][sFunctionName];
}

void MercuryObjectFactory::GetAllClasses( MVector< MString > & vRet )
{
    m_mClasses.VectorIndicies( vRet );
}

void MercuryObjectFactory::GetAllFunctions( const MString & sClass, MVector< MString > vRet )
{
    if( m_mFinalCallbacks.get( sClass ) )
        m_mFinalCallbacks[sClass].VectorIndicies( vRet );
}

---

Hosted by