//===== Copyright � 1996-2005, Valve Corporation, All rights reserved. ======//

 //

 // Purpose: 

 //

 // $Workfile:     $

 // $Date:         $

 //

 //-----------------------------------------------------------------------------

 // $NoKeywords: $

 //===========================================================================//

 #ifndef CONVAR_H

 #define CONVAR_H

 #if _WIN32

 #pragma once

 #endif

 #include "tier0/dbg.h"

 #include "tier1/iconvar.h"

 #include "tier1/utlvector.h"

 #include "tier1/utlstring.h"

 #include "icvar.h"

 #ifdef _WIN32

 #define FORCEINLINE_CVAR FORCEINLINE

 #elif defined _LINUX || defined __APPLE__

 #define FORCEINLINE_CVAR inline

 #else

 #error "implement me"

 #endif

 //-----------------------------------------------------------------------------

 // Forward declarations

 //-----------------------------------------------------------------------------

 class ConVar;

 class CCommand;

 class ConCommand;

 class ConCommandBase;

 struct characterset_t;

 //-----------------------------------------------------------------------------

 // Any executable that wants to use ConVars need to implement one of

 // these to hook up access to console variables.

 //-----------------------------------------------------------------------------

 class IConCommandBaseAccessor

 {

 public:

 	// Flags is a combination of FCVAR flags in cvar.h.

 	// hOut is filled in with a handle to the variable.

 	virtual bool RegisterConCommandBase( ConCommandBase *pVar ) = 0;

 };

 //-----------------------------------------------------------------------------

 // Helper method for console development

 //-----------------------------------------------------------------------------

 #if defined( _X360 ) && !defined( _RETAIL )

 void ConVar_PublishToVXConsole();

 #endif

 //-----------------------------------------------------------------------------

 // Called when a ConCommand needs to execute

 //-----------------------------------------------------------------------------

 typedef void ( *FnCommandCallbackV1_t )( void );

 typedef void ( *FnCommandCallback_t )( const CCommand &command );

 #define COMMAND_COMPLETION_MAXITEMS		64

 #define COMMAND_COMPLETION_ITEM_LENGTH	64

 //-----------------------------------------------------------------------------

 // Returns 0 to COMMAND_COMPLETION_MAXITEMS worth of completion strings

 //-----------------------------------------------------------------------------

 typedef int  ( *FnCommandCompletionCallback )( const char *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] );

 //-----------------------------------------------------------------------------

 // Interface version

 //-----------------------------------------------------------------------------

 class ICommandCallback

 {

 public:

 	virtual void CommandCallback( const CCommand &command ) = 0;

 };

 class ICommandCompletionCallback

 {

 public:

 	virtual int  CommandCompletionCallback( const char *pPartial, CUtlVector< CUtlString > &commands ) = 0;

 };

 //-----------------------------------------------------------------------------

 // Purpose: The base console invoked command/cvar interface

 //-----------------------------------------------------------------------------

 class ConCommandBase

 {

 	friend class CCvar;

 	friend class ConVar;

 	friend class ConCommand;

 	friend void ConVar_Register( int nCVarFlag, IConCommandBaseAccessor *pAccessor );

 	friend void ConVar_PublishToVXConsole();

 	// FIXME: Remove when ConVar changes are done

 	friend class CDefaultCvar;

 public:

 								ConCommandBase( void );

 								ConCommandBase( const char *pName, const char *pHelpString = 0, 

 									int flags = 0 );

 	virtual						~ConCommandBase( void );

 	virtual	bool				IsCommand( void ) const;

 	// Check flag

 	virtual bool				IsFlagSet( int flag ) const;

 	// Set flag

 	virtual void				AddFlags( int flags );

 	// Return name of cvar

 	virtual const char			*GetName( void ) const;

 	// Return help text for cvar

 	virtual const char			*GetHelpText( void ) const;

 	// Deal with next pointer

 	const ConCommandBase		*GetNext( void ) const;

 	ConCommandBase				*GetNext( void );

 	void SetNext(ConCommandBase *pBase)

 	{

 		m_pNext = pBase;

 	}

 	virtual bool				IsRegistered( void ) const;

 	// Returns the DLL identifier

 	virtual CVarDLLIdentifier_t	GetDLLIdentifier() const;

 protected:

 	virtual void				Create( const char *pName, const char *pHelpString = 0, 

 									int flags = 0 );

 	// Used internally by OneTimeInit to initialize/shutdown

 	virtual void				Init();

 	void						Shutdown();

 	// Internal copy routine ( uses new operator from correct module )

 	char						*CopyString( const char *from );

 private:

 	// Next ConVar in chain

 	// Prior to register, it points to the next convar in the DLL.

 	// Once registered, though, m_pNext is reset to point to the next

 	// convar in the global list

 	ConCommandBase				*m_pNext;

 	// Has the cvar been added to the global list?

 	bool						m_bRegistered;

 	// Static data

 	const char 					*m_pszName;

 	const char 					*m_pszHelpString;

 	// ConVar flags

 	int							m_nFlags;

 protected:

 	// ConVars add themselves to this list for the executable. 

 	// Then ConVar_Register runs through  all the console variables 

 	// and registers them into a global list stored in vstdlib.dll

 	static ConCommandBase		*s_pConCommandBases;

 	// ConVars in this executable use this 'global' to access values.

 	static IConCommandBaseAccessor	*s_pAccessor;

 public: // Hackalicous

 	inline int GetFlags() const

 	{

 		return m_nFlags;

 	}

 	inline void SetFlags(int flags)	

 	{ 

 		m_nFlags = flags; 

 	}

 };

 //-----------------------------------------------------------------------------

 // Command tokenizer

 //-----------------------------------------------------------------------------

 class CCommand

 {

 public:

 	CCommand();

 	CCommand( int nArgC, const char **ppArgV );

 	bool Tokenize( const char *pCommand, characterset_t *pBreakSet = NULL );

 	void Reset();

 	int ArgC() const;

 	const char **ArgV() const;

 	const char *ArgS() const;					// All args that occur after the 0th arg, in string form

 	const char *GetCommandString() const;		// The entire command in string form, including the 0th arg

 	const char *operator[]( int nIndex ) const;	// Gets at arguments

 	const char *Arg( int nIndex ) const;		// Gets at arguments

 	// Helper functions to parse arguments to commands.

 	const char* FindArg( const char *pName ) const;

 	int FindArgInt( const char *pName, int nDefaultVal ) const;

 	static int MaxCommandLength();

 	static characterset_t* DefaultBreakSet();

 private:

 	enum

 	{

 		COMMAND_MAX_ARGC = 64,

 		COMMAND_MAX_LENGTH = 512,

 	};

 	int		m_nArgc;

 	int		m_nArgv0Size;

 	char	m_pArgSBuffer[ COMMAND_MAX_LENGTH ];

 	char	m_pArgvBuffer[ COMMAND_MAX_LENGTH ];

 	const char*	m_ppArgv[ COMMAND_MAX_ARGC ];

 };

 inline int CCommand::MaxCommandLength()

 {

 	return COMMAND_MAX_LENGTH - 1;

 }

 inline int CCommand::ArgC() const

 {

 	return m_nArgc;

 }

 inline const char **CCommand::ArgV() const

 {

 	return m_nArgc ? (const char**)m_ppArgv : NULL;

 }

 inline const char *CCommand::ArgS() const

 {

 	return m_nArgv0Size ? &m_pArgSBuffer[m_nArgv0Size] : "";

 }

 inline const char *CCommand::GetCommandString() const

 {

 	return m_nArgc ? m_pArgSBuffer : "";

 }

 inline const char *CCommand::Arg( int nIndex ) const

 {

 	// FIXME: Many command handlers appear to not be particularly careful

 	// about checking for valid argc range. For now, we're going to

 	// do the extra check and return an empty string if it's out of range

 	if ( nIndex < 0 || nIndex >= m_nArgc )

 		return "";

 	return m_ppArgv[nIndex];

 }

 inline const char *CCommand::operator[]( int nIndex ) const

 {

 	return Arg( nIndex );

 }

 //-----------------------------------------------------------------------------

 // Purpose: The console invoked command

 //-----------------------------------------------------------------------------

 class ConCommand : public ConCommandBase

 {

 friend class CCvar;

 public:

 	typedef ConCommandBase BaseClass;

 	ConCommand( const char *pName, FnCommandCallbackV1_t callback, 

 		const char *pHelpString = 0, int flags = 0, FnCommandCompletionCallback completionFunc = 0 );

 	ConCommand( const char *pName, FnCommandCallback_t callback, 

 		const char *pHelpString = 0, int flags = 0, FnCommandCompletionCallback completionFunc = 0 );

 	ConCommand( const char *pName, ICommandCallback *pCallback, 

 		const char *pHelpString = 0, int flags = 0, ICommandCompletionCallback *pCommandCompletionCallback = 0 );

 	virtual ~ConCommand( void );

 	virtual	bool IsCommand( void ) const;

 	virtual int AutoCompleteSuggest( const char *partial, CUtlVector< CUtlString > &commands );

 	virtual bool CanAutoComplete( void );

 	// Invoke the function

 	virtual void Dispatch( const CCommand &command );

 private:

 	// NOTE: To maintain backward compat, we have to be very careful:

 	// All public virtual methods must appear in the same order always

 	// since engine code will be calling into this code, which *does not match*

 	// in the mod code; it's using slightly different, but compatible versions

 	// of this class. Also: Be very careful about adding new fields to this class.

 	// Those fields will not exist in the version of this class that is instanced

 	// in mod code.

 	// Call this function when executing the command

 	union

 	{

 		FnCommandCallbackV1_t m_fnCommandCallbackV1;

 		FnCommandCallback_t m_fnCommandCallback;

 		ICommandCallback *m_pCommandCallback; 

 	};

 	union

 	{

 		FnCommandCompletionCallback	m_fnCompletionCallback;

 		ICommandCompletionCallback *m_pCommandCompletionCallback;

 	};

 	bool m_bHasCompletionCallback : 1;

 	bool m_bUsingNewCommandCallback : 1;

 	bool m_bUsingCommandCallbackInterface : 1;

 public: // Hackalicous

 	inline FnCommandCallback_t GetCallback() const

 	{ 

 		return m_fnCommandCallback; 

 	}

 };

 //-----------------------------------------------------------------------------

 // Purpose: A console variable

 //-----------------------------------------------------------------------------

 class ConVar : public ConCommandBase, public IConVar

 {

 friend class CCvar;

 friend class ConVarRef;

 public:

 	typedef ConCommandBase BaseClass;

 								ConVar( const char *pName, const char *pDefaultValue, int flags = 0);

 								ConVar( const char *pName, const char *pDefaultValue, int flags, 

 									const char *pHelpString );

 								ConVar( const char *pName, const char *pDefaultValue, int flags, 

 									const char *pHelpString, bool bMin, float fMin, bool bMax, float fMax );

 								ConVar( const char *pName, const char *pDefaultValue, int flags, 

 									const char *pHelpString, FnChangeCallback_t callback );

 								ConVar( const char *pName, const char *pDefaultValue, int flags, 

 									const char *pHelpString, bool bMin, float fMin, bool bMax, float fMax,

 									FnChangeCallback_t callback );

 	virtual						~ConVar( void );

 	virtual bool				IsFlagSet( int flag ) const;

 	virtual const char*			GetHelpText( void ) const;

 	virtual bool				IsRegistered( void ) const;

 	virtual const char			*GetName( void ) const;

 	virtual void				AddFlags( int flags );

 	virtual	bool				IsCommand( void ) const;

 	// Install a change callback (there shouldn't already be one....)

 	void InstallChangeCallback( FnChangeCallback_t callback );

 	// Retrieve value

 	FORCEINLINE_CVAR float			GetFloat( void ) const;

 	FORCEINLINE_CVAR int			GetInt( void ) const;

 	FORCEINLINE_CVAR bool			GetBool() const {  return !!GetInt(); }

 	FORCEINLINE_CVAR char const	   *GetString( void ) const;

 	// Any function that allocates/frees memory needs to be virtual or else you'll have crashes

 	//  from alloc/free across dll/exe boundaries.

 	// These just call into the IConCommandBaseAccessor to check flags and set the var (which ends up calling InternalSetValue).

 	virtual void				SetValue( const char *value );

 	virtual void				SetValue( float value );

 	virtual void				SetValue( int value );

 	// Reset to default value

 	void						Revert( void );

 	// True if it has a min/max setting

 	bool						GetMin( float& minVal ) const;

 	bool						GetMax( float& maxVal ) const;

 	const char					*GetDefault( void ) const;

 private:

 	// Called by CCvar when the value of a var is changing.

 	virtual void				InternalSetValue(const char *value);

 	// For CVARs marked FCVAR_NEVER_AS_STRING

 	virtual void				InternalSetFloatValue( float fNewValue );

 	virtual void				InternalSetIntValue( int nValue );

 	virtual bool				ClampValue( float& value );

 	virtual void				ChangeStringValue( const char *tempVal, float flOldValue );

 	virtual void				Create( const char *pName, const char *pDefaultValue, int flags = 0,

 									const char *pHelpString = 0, bool bMin = false, float fMin = 0.0,

 									bool bMax = false, float fMax = false, FnChangeCallback_t callback = 0 );

 	// Used internally by OneTimeInit to initialize.

 	virtual void				Init();

 private:

 	// This either points to "this" or it points to the original declaration of a ConVar.

 	// This allows ConVars to exist in separate modules, and they all use the first one to be declared.

 	// m_pParent->m_pParent must equal m_pParent (ie: m_pParent must be the root, or original, ConVar).

 	ConVar						*m_pParent;

 	// Static data

 	const char					*m_pszDefaultValue;

 	// Value

 	// Dynamically allocated

 	char						*m_pszString;

 	int							m_StringLength;

 	// Values

 	float						m_fValue;

 	int							m_nValue;

 	// Min/Max values

 	bool						m_bHasMin;

 	float						m_fMinVal;

 	bool						m_bHasMax;

 	float						m_fMaxVal;

 	// Call this function when ConVar changes

 	FnChangeCallback_t			m_fnChangeCallback;

 public: // Hackalicous

 	inline FnChangeCallback_t GetCallback() const

 	{

 		return m_fnChangeCallback;

 	}

 	inline void SetMin(bool set, float min=0.0)

 	{ 

 		m_bHasMin = set; 

 		m_fMinVal = min; 

 	}

 	inline void SetMax(bool set, float max=0.0)

 	{

 		m_bHasMax = set;

 		m_fMaxVal = max; 

 	}

 };

 //-----------------------------------------------------------------------------

 // Purpose: Return ConVar value as a float

 // Output : float

 //-----------------------------------------------------------------------------

 FORCEINLINE_CVAR float ConVar::GetFloat( void ) const

 {

 	return m_pParent->m_fValue;

 }

 //-----------------------------------------------------------------------------

 // Purpose: Return ConVar value as an int

 // Output : int

 //-----------------------------------------------------------------------------

 FORCEINLINE_CVAR int ConVar::GetInt( void ) const 

 {

 	return m_pParent->m_nValue;

 }

 //-----------------------------------------------------------------------------

 // Purpose: Return ConVar value as a string, return "" for bogus string pointer, etc.

 // Output : const char *

 //-----------------------------------------------------------------------------

 FORCEINLINE_CVAR const char *ConVar::GetString( void ) const 

 {

 	if ( m_nFlags & FCVAR_NEVER_AS_STRING )

 		return "FCVAR_NEVER_AS_STRING";

 	return ( m_pParent->m_pszString ) ? m_pParent->m_pszString : "";

 }

 //-----------------------------------------------------------------------------

 // Used to read/write convars that already exist (replaces the FindVar method)

 //-----------------------------------------------------------------------------

 class ConVarRef

 {

 public:

 	ConVarRef( const char *pName );

 	ConVarRef( const char *pName, bool bIgnoreMissing );

 	ConVarRef( IConVar *pConVar );

 	void Init( const char *pName, bool bIgnoreMissing );

 	bool IsValid() const;

 	bool IsFlagSet( int nFlags ) const;

 	IConVar *GetLinkedConVar();

 	// Get/Set value

 	float GetFloat( void ) const;

 	int GetInt( void ) const;

 	bool GetBool() const { return !!GetInt(); }

 	const char *GetString( void ) const;

 	void SetValue( const char *pValue );

 	void SetValue( float flValue );

 	void SetValue( int nValue );

 	void SetValue( bool bValue );

 	const char *GetName() const;

 	const char *GetDefault() const;

 private:

 	// High-speed method to read convar data

 	IConVar *m_pConVar;

 	ConVar *m_pConVarState;

 };

 //-----------------------------------------------------------------------------

 // Did we find an existing convar of that name?

 //-----------------------------------------------------------------------------

 FORCEINLINE_CVAR bool ConVarRef::IsFlagSet( int nFlags ) const

 {

 	return ( m_pConVar->IsFlagSet( nFlags ) != 0 );

 }

 FORCEINLINE_CVAR IConVar *ConVarRef::GetLinkedConVar()

 {

 	return m_pConVar;

 }

 FORCEINLINE_CVAR const char *ConVarRef::GetName() const

 {

 	return m_pConVar->GetName();

 }

 //-----------------------------------------------------------------------------

 // Purpose: Return ConVar value as a float

 //-----------------------------------------------------------------------------

 FORCEINLINE_CVAR float ConVarRef::GetFloat( void ) const

 {

 	return m_pConVarState->m_fValue;

 }

 //-----------------------------------------------------------------------------

 // Purpose: Return ConVar value as an int

 //-----------------------------------------------------------------------------

 FORCEINLINE_CVAR int ConVarRef::GetInt( void ) const 

 {

 	return m_pConVarState->m_nValue;

 }

 //-----------------------------------------------------------------------------

 // Purpose: Return ConVar value as a string, return "" for bogus string pointer, etc.

 //-----------------------------------------------------------------------------

 FORCEINLINE_CVAR const char *ConVarRef::GetString( void ) const 

 {

 	Assert( !IsFlagSet( FCVAR_NEVER_AS_STRING ) );

 	return m_pConVarState->m_pszString;

 }

 FORCEINLINE_CVAR void ConVarRef::SetValue( const char *pValue )

 {

 	m_pConVar->SetValue( pValue );

 }

 FORCEINLINE_CVAR void ConVarRef::SetValue( float flValue )

 {

 	m_pConVar->SetValue( flValue );

 }

 FORCEINLINE_CVAR void ConVarRef::SetValue( int nValue )

 {

 	m_pConVar->SetValue( nValue );

 }

 FORCEINLINE_CVAR void ConVarRef::SetValue( bool bValue )

 {

 	m_pConVar->SetValue( bValue ? 1 : 0 );

 }

 FORCEINLINE_CVAR const char *ConVarRef::GetDefault() const

 {

 	return m_pConVarState->m_pszDefaultValue;

 }

 //-----------------------------------------------------------------------------

 // Called by the framework to register ConCommands with the ICVar

 //-----------------------------------------------------------------------------

 void ConVar_Register( int nCVarFlag = 0, IConCommandBaseAccessor *pAccessor = NULL );

 void ConVar_Unregister( );

 //-----------------------------------------------------------------------------

 // Utility methods 

 //-----------------------------------------------------------------------------

 void ConVar_PrintFlags( const ConCommandBase *var );

 void ConVar_PrintDescription( const ConCommandBase *pVar );

 //-----------------------------------------------------------------------------

 // Purpose: Utility class to quickly allow ConCommands to call member methods

 //-----------------------------------------------------------------------------

 #if defined _MSC_VER

 #pragma warning (disable : 4355 )

 #endif

 template< class T >

 class CConCommandMemberAccessor : public ConCommand, public ICommandCallback, public ICommandCompletionCallback

 {

 	typedef ConCommand BaseClass;

 	typedef void ( T::*FnMemberCommandCallback_t )( const CCommand &command );

 	typedef int  ( T::*FnMemberCommandCompletionCallback_t )( const char *pPartial, CUtlVector< CUtlString > &commands );

 public:

 	CConCommandMemberAccessor( T* pOwner, const char *pName, FnMemberCommandCallback_t callback, const char *pHelpString = 0,

 		int flags = 0, FnMemberCommandCompletionCallback_t completionFunc = 0 ) :

 		BaseClass( pName, this, pHelpString, flags, ( completionFunc != 0 ) ? this : NULL )

 	{

 		m_pOwner = pOwner;

 		m_Func = callback;

 		m_CompletionFunc = completionFunc;

 	}

 	~CConCommandMemberAccessor()

 	{

 		Shutdown();

 	}

 	void SetOwner( T* pOwner )

 	{

 		m_pOwner = pOwner;

 	}

 	virtual void CommandCallback( const CCommand &command )

 	{

 		Assert( m_pOwner && m_Func );

 		(m_pOwner->*m_Func)( command );

 	}

 	virtual int  CommandCompletionCallback( const char *pPartial, CUtlVector< CUtlString > &commands )

 	{

 		Assert( m_pOwner && m_CompletionFunc );

 		return (m_pOwner->*m_CompletionFunc)( pPartial, commands );

 	}

 private:

 	T* m_pOwner;

 	FnMemberCommandCallback_t m_Func;

 	FnMemberCommandCompletionCallback_t m_CompletionFunc;

 };

 #if defined _MSC_VER

 #pragma warning ( default : 4355 )

 #endif

 //-----------------------------------------------------------------------------

 // Purpose: Utility macros to quicky generate a simple console command

 //-----------------------------------------------------------------------------

 #define CON_COMMAND( name, description ) \

    static void name( const CCommand &args ); \

    static ConCommand name##_command( #name, name, description ); \

    static void name( const CCommand &args )

 #define CON_COMMAND_F( name, description, flags ) \

    static void name( const CCommand &args ); \

    static ConCommand name##_command( #name, name, description, flags ); \

    static void name( const CCommand &args )

 #define CON_COMMAND_F_COMPLETION( name, description, flags, completion ) \

 	static void name( const CCommand &args ); \

 	static ConCommand name##_command( #name, name, description, flags, completion ); \

 	static void name( const CCommand &args )

 #define CON_COMMAND_EXTERN( name, _funcname, description ) \

 	void _funcname( const CCommand &args ); \

 	static ConCommand name##_command( #name, _funcname, description ); \

 	void _funcname( const CCommand &args )

 #define CON_COMMAND_EXTERN_F( name, _funcname, description, flags ) \

 	void _funcname( const CCommand &args ); \

 	static ConCommand name##_command( #name, _funcname, description, flags ); \

 	void _funcname( const CCommand &args )

 #define CON_COMMAND_MEMBER_F( _thisclass, name, _funcname, description, flags ) \

 	void _funcname( const CCommand &args );						\

 	friend class CCommandMemberInitializer_##_funcname;			\

 	class CCommandMemberInitializer_##_funcname					\

 	{															\

 	public:														\

 		CCommandMemberInitializer_##_funcname() : m_ConCommandAccessor( NULL, name, &_thisclass::_funcname, description, flags )	\

 		{														\

 			m_ConCommandAccessor.SetOwner( GET_OUTER( _thisclass, m_##_funcname##_register ) );	\

 		}														\

 	private:													\

 		CConCommandMemberAccessor< _thisclass > m_ConCommandAccessor;	\

 	};															\

 																\

 	CCommandMemberInitializer_##_funcname m_##_funcname##_register;		\

 #endif // CONVAR_H