diff --git a/game/server/enginecallback.h b/game/server/enginecallback.h index fb4059fe..1fc305c2 100644 --- a/game/server/enginecallback.h +++ b/game/server/enginecallback.h @@ -22,8 +22,7 @@ class IFileSystem; // include FileSystem.h class IUniformRandomStream; // include vstdlib/random.h class IEngineSound; // include engine/IEngineSound.h -class IVEngineServer; -class IVoiceServer; +class IVEngineServer; class IStaticPropMgrServer; class ISpatialPartition; class IVModelInfo; @@ -40,7 +39,6 @@ class CSteamAPIContext; class CSteamGameServerAPIContext; extern IVEngineServer *engine; -extern IVoiceServer *g_pVoiceServer; extern IFileSystem *filesystem; extern IStaticPropMgrServer *staticpropmgr; extern ISpatialPartition *partition; diff --git a/game/server/gameinterface.cpp b/game/server/gameinterface.cpp index da6ea568..93fcc909 100644 --- a/game/server/gameinterface.cpp +++ b/game/server/gameinterface.cpp @@ -23,7 +23,6 @@ #include "ai_saverestore.h" #include "ai_networkmanager.h" #include "ndebugoverlay.h" -#include "ivoiceserver.h" #include #include "movehelper_server.h" #include "networkstringtable_gamedll.h" @@ -154,7 +153,6 @@ CUtlLinkedList g_MapEntityRefs; // Engine interfaces. IVEngineServer *engine = NULL; -IVoiceServer *g_pVoiceServer = NULL; #if !defined(_STATIC_LINKED) IFileSystem *filesystem = NULL; #else @@ -655,8 +653,6 @@ bool CServerGameDLL::DLLInit( CreateInterfaceFn appSystemFactory, // init each (seperated for ease of debugging) if ( (engine = (IVEngineServer*)appSystemFactory(INTERFACEVERSION_VENGINESERVER, NULL)) == NULL ) return false; - if ( (g_pVoiceServer = (IVoiceServer*)appSystemFactory(INTERFACEVERSION_VOICESERVER, NULL)) == NULL ) - return false; if ( (networkstringtable = (INetworkStringTableContainer *)appSystemFactory(INTERFACENAME_NETWORKSTRINGTABLESERVER,NULL)) == NULL ) return false; if ( (staticpropmgr = (IStaticPropMgrServer *)appSystemFactory(INTERFACEVERSION_STATICPROPMGR_SERVER,NULL)) == NULL ) diff --git a/linux_sdk/Makefile.tier1 b/linux_sdk/Makefile.tier1 index 670fb434..839ef974 100644 --- a/linux_sdk/Makefile.tier1 +++ b/linux_sdk/Makefile.tier1 @@ -50,7 +50,6 @@ LIB_OBJS= \ $(LIB_OBJ_DIR)/undiff.o \ $(LIB_OBJ_DIR)/uniqueid.o \ $(LIB_OBJ_DIR)/utlbufferutil.o \ - $(LIB_OBJ_DIR)/utlsymbol.o \ all: dirs $(NAME).$(SHLIBEXT) diff --git a/public/const.h b/public/const.h index 08a25603..e85b2e4c 100644 --- a/public/const.h +++ b/public/const.h @@ -355,10 +355,10 @@ enum RenderFx_t : unsigned char enum Collision_Group_t { - COLLISION_GROUP_NONE = 0, - COLLISION_GROUP_UNKNOWN1, - COLLISION_GROUP_UNKNOWN2, - COLLISION_GROUP_UNKNOWN3, + COLLISION_GROUP_ALWAYS = 0, + COLLISION_GROUP_NEVER, + COLLISION_GROUP_TRIGGER, + COLLISION_GROUP_CONDITIONALLY_SOLID, COLLISION_GROUP_DEFAULT, COLLISION_GROUP_DEBRIS, // Collides with nothing but world, static stuff and triggers COLLISION_GROUP_INTERACTIVE_DEBRIS, // Collides with everything except other interactive debris or debris diff --git a/public/eiface.h b/public/eiface.h index 77afbf29..a1b35399 100644 --- a/public/eiface.h +++ b/public/eiface.h @@ -313,9 +313,12 @@ public: virtual void unk101() = 0; virtual void unk102() = 0; - virtual void unk103() = 0; - virtual void unk104() = 0; - virtual void unk105() = 0; + + // Use these to setup who can hear whose voice. + // Pass in client indices (which are their ent indices - 1). + virtual bool GetClientListening(CPlayerSlot iReceiver, CPlayerSlot iSender) = 0; + virtual bool SetClientListening(CPlayerSlot iReceiver, CPlayerSlot iSender, bool bListen) = 0; + virtual bool SetClientProximity(CPlayerSlot iReceiver, CPlayerSlot iSender, bool bUseProximity) = 0; virtual void unk106() = 0; virtual void unk107() = 0; @@ -571,7 +574,7 @@ public: virtual void ClientSetupVisibility( CPlayerSlot slot, vis_info_t *visinfo ) = 0; // A block of CUserCmds has arrived from the user, decode them and buffer for execution during player simulation - virtual float ProcessUsercmds( CPlayerSlot slot, bf_read *buf, int numcmds, bool ignore, bool paused ) = 0; + virtual int ProcessUsercmds( CPlayerSlot slot, bf_read *buf, int numcmds, bool ignore, bool paused ) = 0; virtual bool IsPlayerSlotOccupied( CPlayerSlot slot ) = 0; diff --git a/public/filesystem.h b/public/filesystem.h index 70d261e8..90f0c443 100644 --- a/public/filesystem.h +++ b/public/filesystem.h @@ -37,7 +37,11 @@ class ILowLevelFileIO; class CSteamID; typedef void * FileHandle_t; -typedef int FileFindHandle_t; +struct FileFindHandle_t +{ + IFileSystem *m_pFileSystem; + intp m_nFindDataIndex; +}; typedef void (*FileSystemLoggingFunc_t)( const char *fileName, const char *accessType ); typedef int WaitForResourcesHandle_t; @@ -575,9 +579,9 @@ public: // FindFirst/FindNext. Also see FindFirstEx. virtual const char *FindFirst( const char *pWildCard, FileFindHandle_t *pHandle ) = 0; - virtual const char *FindNext( FileFindHandle_t handle ) = 0; - virtual bool FindIsDirectory( FileFindHandle_t handle ) = 0; - virtual void FindClose( FileFindHandle_t handle ) = 0; + virtual const char *FindNext( FileFindHandle_t &handle ) = 0; + virtual bool FindIsDirectory( FileFindHandle_t &handle ) = 0; + virtual void FindClose( FileFindHandle_t &handle ) = 0; // Same as FindFirst, but you can filter by path ID, which can make it faster. virtual const char *FindFirstEx( const char *pWildCard, const char *pPathID, FileFindHandle_t *pHandle ) = 0; diff --git a/public/igameevents.h b/public/igameevents.h index 70009b31..2cca21a1 100644 --- a/public/igameevents.h +++ b/public/igameevents.h @@ -119,14 +119,14 @@ public: virtual void SetFloat( const GameEventKeySymbol_t &keySymbol, float value ) = 0; virtual void SetString( const GameEventKeySymbol_t &keySymbol, const char *value ) = 0; virtual void SetPtr( const GameEventKeySymbol_t &keySymbol, void *value ) = 0; - + + virtual void SetEntity(const GameEventKeySymbol_t &keySymbol, CEntityInstance *value) = 0; virtual void SetEntity( const GameEventKeySymbol_t &keySymbol, CEntityIndex value ) = 0; - virtual void SetEntity( const GameEventKeySymbol_t &keySymbol, CEntityInstance *value ) = 0; - // Also sets the _pawn key - virtual void SetPlayer( const GameEventKeySymbol_t &keySymbol, CPlayerSlot value ) = 0; // Also sets the _pawn key (Expects pawn entity to be passed) virtual void SetPlayer( const GameEventKeySymbol_t &keySymbol, CEntityInstance *pawn ) = 0; + // Also sets the _pawn key + virtual void SetPlayer( const GameEventKeySymbol_t &keySymbol, CPlayerSlot value ) = 0; // Expects pawn entity to be passed, will set the controller entity as a controllerKeyName // and pawn entity as a pawnKeyName. diff --git a/public/ivoiceserver.h b/public/ivoiceserver.h deleted file mode 100644 index 4288fb36..00000000 --- a/public/ivoiceserver.h +++ /dev/null @@ -1,34 +0,0 @@ -//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============// -// -// Purpose: This module defines the IVoiceServer interface, which is used by -// game code to control which clients are listening to which other -// clients' voice streams. -// -// $NoKeywords: $ -//=============================================================================// - -#ifndef IVOICESERVER_H -#define IVOICESERVER_H - - -#include "interface.h" - - -#define INTERFACEVERSION_VOICESERVER "VoiceServer002" - - -abstract_class IVoiceServer -{ -public: - virtual ~IVoiceServer() {} - - // Use these to setup who can hear whose voice. - // Pass in client indices (which are their ent indices - 1). - virtual bool GetClientListening(int iReceiver, int iSender) = 0; - virtual bool SetClientListening(int iReceiver, int iSender, bool bListen) = 0; - virtual bool SetClientProximity(int iReceiver, int iSender, bool bUseProximity) = 0; -}; - - -#endif - diff --git a/public/tier1/UtlStringMap.h b/public/tier1/UtlStringMap.h index e102d2a1..ee60c850 100644 --- a/public/tier1/UtlStringMap.h +++ b/public/tier1/UtlStringMap.h @@ -1,4 +1,4 @@ -//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======// +//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======// // // Purpose: // @@ -55,9 +55,9 @@ public: return m_SymbolTable.Find( pString ); } - UtlSymId_t AddString( const char *pString ) + UtlSymId_t AddString( const char *pString, bool* created = NULL ) { - CUtlSymbol symbol = m_SymbolTable.AddString( pString ); + CUtlSymbol symbol = m_SymbolTable.AddString( pString, created ); int index = ( int )( UtlSymId_t )symbol; if( m_Vector.Count() <= index ) { diff --git a/public/tier1/utlsymbol.h b/public/tier1/utlsymbol.h index 702632c8..0c23f12f 100644 --- a/public/tier1/utlsymbol.h +++ b/public/tier1/utlsymbol.h @@ -1,4 +1,4 @@ -//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======// +//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======// // // Purpose: Defines a symbol table // @@ -102,7 +102,7 @@ public: ~CUtlSymbolTable(); // Finds and/or creates a symbol based on the string - CUtlSymbol AddString( const char* pString ); + CUtlSymbol AddString( const char* pString, bool* created = NULL ); // Finds the symbol for pString CUtlSymbol Find( const char* pString ) const; @@ -174,7 +174,7 @@ protected: // stores the string data CUtlVector m_StringPools; - + uint8 unknown[56]; private: int FindPoolWithSpace( int len ) const; const char* StringFromIndex( const CStringPoolIndex &index ) const; @@ -193,10 +193,10 @@ public: { } - CUtlSymbol AddString( const char* pString ) + CUtlSymbol AddString( const char* pString, bool* created = NULL ) { m_lock.LockForWrite(); - CUtlSymbol result = CUtlSymbolTable::AddString( pString ); + CUtlSymbol result = CUtlSymbolTable::AddString( pString, created ); m_lock.UnlockWrite(); return result; } diff --git a/public/tier1/utlsymbollarge.h b/public/tier1/utlsymbollarge.h index 99b6888e..aacf7d93 100644 --- a/public/tier1/utlsymbollarge.h +++ b/public/tier1/utlsymbollarge.h @@ -142,8 +142,8 @@ public: ~CUtlSymbolTableLargeBase() { } // Finds and/or creates a symbol based on the string - CUtlSymbolLarge AddString( const char* pString ); - CUtlSymbolLarge AddString( const char* pString, int nLength ); + CUtlSymbolLarge AddString( const char* pString, bool* created = NULL ); + CUtlSymbolLarge AddString( const char* pString, int nLength, bool* created = NULL ); // Finds the symbol for pString CUtlSymbolLarge Find( const char* pString ) const; @@ -326,7 +326,7 @@ inline CUtlSymbolLarge CUtlSymbolTableLargeBase< CASEINSENSITIVE, PAGE_SIZE, MUT } template < bool CASEINSENSITIVE, size_t PAGE_SIZE, class MUTEX_TYPE > -inline CUtlSymbolLarge CUtlSymbolTableLargeBase< CASEINSENSITIVE, PAGE_SIZE, MUTEX_TYPE >::AddString( const char* pString, int nLength ) +inline CUtlSymbolLarge CUtlSymbolTableLargeBase< CASEINSENSITIVE, PAGE_SIZE, MUTEX_TYPE >::AddString( const char* pString, int nLength, bool* created ) { CUtlSymbolLarge sym; @@ -348,9 +348,9 @@ inline CUtlSymbolLarge CUtlSymbolTableLargeBase< CASEINSENSITIVE, PAGE_SIZE, MUT } template < bool CASEINSENSITIVE, size_t PAGE_SIZE, class MUTEX_TYPE > -inline CUtlSymbolLarge CUtlSymbolTableLargeBase< CASEINSENSITIVE, PAGE_SIZE, MUTEX_TYPE >::AddString( const char* pString ) +inline CUtlSymbolLarge CUtlSymbolTableLargeBase< CASEINSENSITIVE, PAGE_SIZE, MUTEX_TYPE >::AddString( const char* pString, bool* created ) { - return AddString( pString, pString ? strlen( pString ) : 0 ); + return AddString( pString, pString ? strlen( pString ) : 0, created ); } template < bool CASEINSENSITIVE, size_t PAGE_SIZE, class MUTEX_TYPE > diff --git a/tier1/tier1.vcxproj.filters b/tier1/tier1.vcxproj.filters index 997c4320..ece86719 100644 --- a/tier1/tier1.vcxproj.filters +++ b/tier1/tier1.vcxproj.filters @@ -68,9 +68,6 @@ Source Files - - Source Files - diff --git a/tier1/utlsymbol.cpp b/tier1/utlsymbol.cpp deleted file mode 100644 index 385ccaf9..00000000 --- a/tier1/utlsymbol.cpp +++ /dev/null @@ -1,397 +0,0 @@ -//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============// -// -// Purpose: Defines a symbol table -// -// $Header: $ -// $NoKeywords: $ -//=============================================================================// - -#ifdef _MSC_VER -#pragma warning (disable:4514) -#endif - -#include "utlsymbol.h" -#include "KeyValues.h" -#include "tier0/threadtools.h" -#include "tier0/memdbgon.h" -#include "stringpool.h" - -// memdbgon must be the last include file in a .cpp file!!! -#include "tier0/memdbgon.h" - -#define INVALID_STRING_INDEX CStringPoolIndex( 0xFFFF, 0xFFFF ) - -#define MIN_STRING_POOL_SIZE 2048 - -//----------------------------------------------------------------------------- -// globals -//----------------------------------------------------------------------------- - -CUtlSymbolTableMT* CUtlSymbol::s_pSymbolTable = 0; -bool CUtlSymbol::s_bAllowStaticSymbolTable = true; - - -//----------------------------------------------------------------------------- -// symbol methods -//----------------------------------------------------------------------------- - -void CUtlSymbol::Initialize() -{ - // If this assert fails, then the module that this call is in has chosen to disallow - // use of the static symbol table. Usually, it's to prevent confusion because it's easy - // to accidentally use the global symbol table when you really want to use a specific one. - Assert( s_bAllowStaticSymbolTable ); - - // necessary to allow us to create global symbols - static bool symbolsInitialized = false; - if (!symbolsInitialized) - { - s_pSymbolTable = new CUtlSymbolTableMT; - symbolsInitialized = true; - } -} - -//----------------------------------------------------------------------------- -// Purpose: Singleton to delete table on exit from module -//----------------------------------------------------------------------------- -class CCleanupUtlSymbolTable -{ -public: - ~CCleanupUtlSymbolTable() - { - delete CUtlSymbol::s_pSymbolTable; - CUtlSymbol::s_pSymbolTable = NULL; - } -}; - -static CCleanupUtlSymbolTable g_CleanupSymbolTable; - -CUtlSymbolTableMT* CUtlSymbol::CurrTable() -{ - Initialize(); - return s_pSymbolTable; -} - - -//----------------------------------------------------------------------------- -// string->symbol->string -//----------------------------------------------------------------------------- - -CUtlSymbol::CUtlSymbol( const char* pStr ) -{ - m_Id = CurrTable()->AddString( pStr ); -} - -const char* CUtlSymbol::String( ) const -{ - return CurrTable()->String(m_Id); -} - -void CUtlSymbol::DisableStaticSymbolTable() -{ - s_bAllowStaticSymbolTable = false; -} - -//----------------------------------------------------------------------------- -// checks if the symbol matches a string -//----------------------------------------------------------------------------- - -bool CUtlSymbol::operator==( const char* pStr ) const -{ - if (m_Id == UTL_INVAL_SYMBOL) - return false; - return strcmp( String(), pStr ) == 0; -} - - - -//----------------------------------------------------------------------------- -// symbol table stuff -//----------------------------------------------------------------------------- - -inline const char* CUtlSymbolTable::StringFromIndex( const CStringPoolIndex &index ) const -{ - Assert( index.m_iPool < m_StringPools.Count() ); - Assert( index.m_iOffset < m_StringPools[index.m_iPool]->m_TotalLen ); - - return &m_StringPools[index.m_iPool]->m_Data[index.m_iOffset]; -} - - -bool CUtlSymbolTable::CLess::operator()( const CStringPoolIndex &i1, const CStringPoolIndex &i2 ) const -{ - // Need to do pointer math because CUtlSymbolTable is used in CUtlVectors, and hence - // can be arbitrarily moved in memory on a realloc. Yes, this is portable. In reality, - // right now at least, because m_LessFunc is the first member of CUtlRBTree, and m_Lookup - // is the first member of CUtlSymbolTabke, this == pTable - CUtlSymbolTable *pTable = (CUtlSymbolTable *)( (byte *)this - offsetof(CUtlSymbolTable::CTree, m_LessFunc) ) - offsetof(CUtlSymbolTable, m_Lookup ); - const char* str1 = (i1 == INVALID_STRING_INDEX) ? pTable->m_pUserSearchString : - pTable->StringFromIndex( i1 ); - const char* str2 = (i2 == INVALID_STRING_INDEX) ? pTable->m_pUserSearchString : - pTable->StringFromIndex( i2 ); - - if ( !pTable->m_bInsensitive ) - return strcmp( str1, str2 ) < 0; - else - return strcmpi( str1, str2 ) < 0; -} - - -//----------------------------------------------------------------------------- -// constructor, destructor -//----------------------------------------------------------------------------- -CUtlSymbolTable::CUtlSymbolTable( int growSize, int initSize, bool caseInsensitive ) : - m_Lookup( growSize, initSize ), m_bInsensitive( caseInsensitive ), m_StringPools( 8 ) -{ -} - -CUtlSymbolTable::~CUtlSymbolTable() -{ - // Release the stringpool string data - RemoveAll(); -} - - -CUtlSymbol CUtlSymbolTable::Find( const char* pString ) const -{ - if (!pString) - return CUtlSymbol(); - - // Store a special context used to help with insertion - m_pUserSearchString = pString; - - // Passing this special invalid symbol makes the comparison function - // use the string passed in the context - UtlSymId_t idx = m_Lookup.Find( INVALID_STRING_INDEX ); - -#ifdef _DEBUG - m_pUserSearchString = NULL; -#endif - - return CUtlSymbol( idx ); -} - - -int CUtlSymbolTable::FindPoolWithSpace( int len ) const -{ - for ( int i=0; i < m_StringPools.Count(); i++ ) - { - StringPool_t *pPool = m_StringPools[i]; - - if ( (pPool->m_TotalLen - pPool->m_SpaceUsed) >= len ) - { - return i; - } - } - - return -1; -} - - -//----------------------------------------------------------------------------- -// Finds and/or creates a symbol based on the string -//----------------------------------------------------------------------------- - -CUtlSymbol CUtlSymbolTable::AddString( const char* pString ) -{ - if (!pString) - return CUtlSymbol( UTL_INVAL_SYMBOL ); - - CUtlSymbol id = Find( pString ); - - if (id.IsValid()) - return id; - - int len = strlen(pString) + 1; - - // Find a pool with space for this string, or allocate a new one. - int iPool = FindPoolWithSpace( len ); - if ( iPool == -1 ) - { - // Add a new pool. - int newPoolSize = MAX( len, MIN_STRING_POOL_SIZE ); - StringPool_t *pPool = (StringPool_t*)malloc( sizeof( StringPool_t ) + newPoolSize - 1 ); - pPool->m_TotalLen = newPoolSize; - pPool->m_SpaceUsed = 0; - iPool = m_StringPools.AddToTail( pPool ); - } - - // Copy the string in. - StringPool_t *pPool = m_StringPools[iPool]; - Assert( pPool->m_SpaceUsed < 0xFFFF ); // This should never happen, because if we had a string > 64k, it - // would have been given its entire own pool. - - unsigned short iStringOffset = pPool->m_SpaceUsed; - - memcpy( &pPool->m_Data[pPool->m_SpaceUsed], pString, len ); - pPool->m_SpaceUsed += len; - - // didn't find, insert the string into the vector. - CStringPoolIndex index; - index.m_iPool = iPool; - index.m_iOffset = iStringOffset; - - UtlSymId_t idx = m_Lookup.Insert( index ); - return CUtlSymbol( idx ); -} - - -//----------------------------------------------------------------------------- -// Look up the string associated with a particular symbol -//----------------------------------------------------------------------------- - -const char* CUtlSymbolTable::String( CUtlSymbol id ) const -{ - if (!id.IsValid()) - return ""; - - Assert( m_Lookup.IsValidIndex((UtlSymId_t)id) ); - return StringFromIndex( m_Lookup[id] ); -} - - -//----------------------------------------------------------------------------- -// Remove all symbols in the table. -//----------------------------------------------------------------------------- - -void CUtlSymbolTable::RemoveAll() -{ - m_Lookup.Purge(); - - for ( int i=0; i < m_StringPools.Count(); i++ ) - free( m_StringPools[i] ); - - m_StringPools.RemoveAll(); -} - - -//----------------------------------------------------------------------------- -// Purpose: -// Input : *pFileName - -// Output : FileNameHandle_t -//----------------------------------------------------------------------------- -FileNameHandle_t CUtlFilenameSymbolTable::FindOrAddFileName( const char *pFileName ) -{ - if ( !pFileName ) - { - return NULL; - } - - // find first - FileNameHandle_t hFileName = FindFileName( pFileName ); - if ( hFileName ) - { - return hFileName; - } - - // Fix slashes+dotslashes and make lower case first.. - char fn[ MAX_PATH ]; - Q_strncpy( fn, pFileName, sizeof( fn ) ); - Q_RemoveDotSlashes( fn ); -#ifdef _WIN32 - strlwr( fn ); -#endif - - // Split the filename into constituent parts - char basepath[ MAX_PATH ]; - Q_ExtractFilePath( fn, basepath, sizeof( basepath ) ); - char filename[ MAX_PATH ]; - Q_strncpy( filename, fn + Q_strlen( basepath ), sizeof( filename ) ); - - // not found, lock and look again - FileNameHandleInternal_t handle; - m_lock.LockForWrite(); - handle.path = m_StringPool.FindStringHandle( basepath ); - handle.file = m_StringPool.FindStringHandle( filename ); - if ( handle.path && handle.file ) - { - // found - m_lock.UnlockWrite(); - return *( FileNameHandle_t * )( &handle ); - } - - // safely add it - handle.path = m_StringPool.ReferenceStringHandle( basepath ); - handle.file = m_StringPool.ReferenceStringHandle( filename ); - m_lock.UnlockWrite(); - - return *( FileNameHandle_t * )( &handle ); -} - -FileNameHandle_t CUtlFilenameSymbolTable::FindFileName( const char *pFileName ) -{ - if ( !pFileName ) - { - return NULL; - } - - // Fix slashes+dotslashes and make lower case first.. - char fn[ MAX_PATH ]; - Q_strncpy( fn, pFileName, sizeof( fn ) ); - Q_RemoveDotSlashes( fn ); -#ifdef _WIN32 - strlwr( fn ); -#endif - - // Split the filename into constituent parts - char basepath[ MAX_PATH ]; - Q_ExtractFilePath( fn, basepath, sizeof( basepath ) ); - char filename[ MAX_PATH ]; - Q_strncpy( filename, fn + Q_strlen( basepath ), sizeof( filename ) ); - - FileNameHandleInternal_t handle; - - m_lock.LockForRead(); - handle.path = m_StringPool.FindStringHandle(basepath); - handle.file = m_StringPool.FindStringHandle(filename); - m_lock.UnlockRead(); - - if ( handle.path == 0 || handle.file == 0 ) - return NULL; - - return *( FileNameHandle_t * )( &handle ); -} - -//----------------------------------------------------------------------------- -// Purpose: -// Input : handle - -// Output : const char -//----------------------------------------------------------------------------- -bool CUtlFilenameSymbolTable::String( const FileNameHandle_t& handle, char *buf, int buflen ) -{ - buf[ 0 ] = 0; - - FileNameHandleInternal_t *internal = ( FileNameHandleInternal_t * )&handle; - if ( !internal ) - { - return false; - } - - m_lock.LockForRead(); - const char *path = m_StringPool.HandleToString(internal->path); - const char *fn = m_StringPool.HandleToString(internal->file); - m_lock.UnlockRead(); - - if ( !path || !fn ) - { - return false; - } - - Q_strncpy( buf, path, buflen ); - Q_strncat( buf, fn, buflen, COPY_ALL_CHARACTERS ); - - return true; -} - -void CUtlFilenameSymbolTable::RemoveAll() -{ - m_StringPool.FreeAll(); -} - -void CUtlFilenameSymbolTable::SpewStrings() -{ - m_lock.LockForRead(); - m_StringPool.SpewStrings(); - m_lock.UnlockRead(); - -}