CWE-ou-minkata/Sources/Plasma/FeatureLib/pfConsoleCore/pfConsoleContext.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==*/
//////////////////////////////////////////////////////////////////////////////
//                                                                          //
//  pfConsoleContext                                                        //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

#include "hsTypes.h"
#include "pfConsoleContext.h"


//// Static Root Context /////////////////////////////////////////////////////

pfConsoleContext    pfConsoleContext::fRootContext( "global" );

pfConsoleContext    &pfConsoleContext::GetRootContext( void )
{
    return fRootContext;
}

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

pfConsoleContext::pfConsoleContext( const char *name )
{
    fName = ( name != nil ) ? hsStrcpy( name ) : nil;
    fAddWhenNotFound = true;
}

pfConsoleContext::~pfConsoleContext()
{
    Clear();
    delete [] fName;
}

//// Clear ///////////////////////////////////////////////////////////////////

void    pfConsoleContext::Clear( void )
{
    Int32       idx;


    for( idx = fVarValues.GetCount() - 1; idx >= 0; idx-- )
        RemoveVar( idx );
}

//// Getters /////////////////////////////////////////////////////////////////

UInt32  pfConsoleContext::GetNumVars( void ) const
{
    hsAssert( fVarValues.GetCount() == fVarNames.GetCount(), "Mismatch in console var context arrays" );
    return fVarValues.GetCount();
}

const char          *pfConsoleContext::GetVarName( UInt32 idx ) const
{
    hsAssert( fVarValues.GetCount() == fVarNames.GetCount(), "Mismatch in console var context arrays" );

    if( idx >= fVarNames.GetCount() )
    {
        hsAssert( false, "GetVarName() index out of range for console context" );
        return nil;
    }

    return fVarNames[ idx ];
}

pfConsoleCmdParam   &pfConsoleContext::GetVarValue( UInt32 idx ) const
{
    hsAssert( fVarValues.GetCount() == fVarNames.GetCount(), "Mismatch in console var context arrays" );
    hsAssert( idx < fVarValues.GetCount(), "GetVarValue() index out of range for console context" );

    return fVarValues[ idx ];
}


//// FindVar /////////////////////////////////////////////////////////////////

Int32   pfConsoleContext::FindVar( const char *name ) const
{
    UInt32      idx;


    hsAssert( fVarValues.GetCount() == fVarNames.GetCount(), "Mismatch in console var context arrays" );

    for( idx = 0; idx < fVarNames.GetCount(); idx++ )
    {
        if( stricmp( name, fVarNames[ idx ] ) == 0 )
        {
            return (Int32)idx;
        }
    }

    return -1;
}

//// RemoveVar ///////////////////////////////////////////////////////////////

void    pfConsoleContext::RemoveVar( UInt32 idx )
{
    hsAssert( fVarValues.GetCount() == fVarNames.GetCount(), "Mismatch in console var context arrays" );

    if( idx >= fVarValues.GetCount() )
    {
        hsAssert( false, "RemoveVar() index out of range for console context" );
        return;
    }

    delete [] fVarNames[ idx ];
    if( fVarValues[ idx ].GetType() == pfConsoleCmdParam::kString )
        // Necessary because the params won't delete the data themselves
        delete [] ( (char *)fVarValues[ idx ] );

    fVarNames.Remove( idx );
    fVarValues.Remove( idx );
}

//// AddVar Variants /////////////////////////////////////////////////////////

void    pfConsoleContext::IAddVar( const char *name, const pfConsoleCmdParam &value )
{
    fVarNames.Append( hsStrcpy( name ) );
    fVarValues.Append( value );
    
    // Remember, params won't know any better, since by default they don't own a copy of their string
    UInt32 idx = fVarValues.GetCount() - 1;
    if( fVarValues[ idx ].GetType() == pfConsoleCmdParam::kString )
        fVarValues[ idx ].SetString( hsStrcpy( fVarValues[ idx ] ) );
}

void    pfConsoleContext::AddVar( const char *name, const pfConsoleCmdParam &value )
{
    Int32 idx = FindVar( name );
    if( idx != -1 )
    {
        hsAssert( false, "AddVar() failed because variable already in console context" );
        return;
    }

    IAddVar( name, value );
}

void    pfConsoleContext::AddVar( const char *name, int value )
{
    pfConsoleCmdParam   param;
    param.SetInt( value );
    AddVar( name, param );
}

void    pfConsoleContext::AddVar( const char *name, float value )
{
    pfConsoleCmdParam   param;
    param.SetFloat( value );
    AddVar( name, param );
}

void    pfConsoleContext::AddVar( const char *name, const char *value )
{
    pfConsoleCmdParam   param;
    param.SetString( (char *)value );   // It's ok, we'll be copying it soon 'nuf
    AddVar( name, param );
}

void    pfConsoleContext::AddVar( const char *name, char value )
{
    pfConsoleCmdParam   param;
    param.SetChar( value );
    AddVar( name, param );
}

void    pfConsoleContext::AddVar( const char *name, bool value )
{
    pfConsoleCmdParam   param;
    param.SetBool( value );
    AddVar( name, param );
}

//// SetVar Variants /////////////////////////////////////////////////////////

hsBool  pfConsoleContext::SetVar( UInt32 idx, const pfConsoleCmdParam &value )
{
    hsAssert( fVarValues.GetCount() == fVarNames.GetCount(), "Mismatch in console var context arrays" );
    if( idx >= fVarValues.GetCount() )
    {
        hsAssert( false, "SetVar() index out of range for console context" );
        return false;
    }

    if( fVarValues[ idx ].GetType() == pfConsoleCmdParam::kString )
    {
        // Remember, params won't know any better, since by default they don't own a copy of their string
        delete [] ( (char *)fVarValues[ idx ] );
    }

    fVarValues[ idx ] = value;
    if( fVarValues[ idx ].GetType() == pfConsoleCmdParam::kString )
        fVarValues[ idx ].SetString( hsStrcpy( fVarValues[ idx ] ) );

    return true;
}

hsBool  pfConsoleContext::SetVar( const char *name, const pfConsoleCmdParam &value )
{
    Int32 idx = FindVar( name );
    if( idx == -1 )
    {
        if( fAddWhenNotFound )
        {
            // Don't panic, just add
            IAddVar( name, value );
            return true;
        }
        return false;
    }

    return SetVar( idx, value );
}

hsBool  pfConsoleContext::SetVar( const char *name, int value )
{
    pfConsoleCmdParam   param;
    param.SetInt( value );
    return SetVar( name, param );
}

hsBool  pfConsoleContext::SetVar( const char *name, float value )
{
    pfConsoleCmdParam   param;
    param.SetFloat( value );
    return SetVar( name, param );
}

hsBool  pfConsoleContext::SetVar( const char *name, const char *value )
{
    pfConsoleCmdParam   param;
    param.SetString( (char *)value );   // Don't worry, we'll be copying it soon 'nuf
    return SetVar( name, param );
}

hsBool  pfConsoleContext::SetVar( const char *name, char value )
{
    pfConsoleCmdParam   param;
    param.SetChar( value );
    return SetVar( name, param );
}

hsBool  pfConsoleContext::SetVar( const char *name, bool value )
{
    pfConsoleCmdParam   param;
    param.SetBool( value );
    return SetVar( name, param );
}