Fix line endings. WHAMMY.

1 files changed, 277 insertions, 277 deletions

diff --git a/mp/src/public/tier1/datamanager.h b/mp/src/public/tier1/datamanager.h
index 6c72bf9e..88030547 100644
--- a/mp/src/public/tier1/datamanager.h
+++ b/mp/src/public/tier1/datamanager.h
@@ -1,277 +1,277 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//

-//

-// Purpose: 

-//

-//=============================================================================//

-

-#ifndef RESOURCEMANAGER_H

-#define RESOURCEMANAGER_H

-#ifdef _WIN32

-#pragma once

-#endif

-

-#include "tier0/threadtools.h"

-#include "utlmultilist.h"

-#include "utlvector.h"

-

-FORWARD_DECLARE_HANDLE( memhandle_t );

-

-#define INVALID_MEMHANDLE ((memhandle_t)0xffffffff)

-

-class CDataManagerBase

-{

-public:

-

-	// public API

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

-	// memhandle_t			CreateResource( params ) // implemented by derived class

-	void					DestroyResource( memhandle_t handle );

-

-	// type-safe implementation in derived class

-	//void					*LockResource( memhandle_t handle );

-	int						UnlockResource( memhandle_t handle );

-	void					TouchResource( memhandle_t handle );

-	void					MarkAsStale( memhandle_t handle );		// move to head of LRU

-

-	int						LockCount( memhandle_t handle );

-	int						BreakLock( memhandle_t handle );

-	int						BreakAllLocks();

-

-	// HACKHACK: For convenience - offers no lock protection 

-	// type-safe implementation in derived class

-	//void					*GetResource_NoLock( memhandle_t handle );

-

-	unsigned int			TargetSize();

-	unsigned int			AvailableSize();

-	unsigned int			UsedSize();

-

-	void					NotifySizeChanged( memhandle_t handle, unsigned int oldSize, unsigned int newSize );

-

-	void					SetTargetSize( unsigned int targetSize );

-

-	// NOTE: flush is equivalent to Destroy

-	unsigned int			FlushAllUnlocked();

-	unsigned int			FlushToTargetSize();

-	unsigned int			FlushAll();

-	unsigned int			Purge( unsigned int nBytesToPurge );

-	unsigned int			EnsureCapacity( unsigned int size );

-

-	// Thread lock

-	virtual void			Lock() {}

-	virtual bool			TryLock() { return true; }

-	virtual void			Unlock() {}

-

-	// Iteration

-

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

-

-	// Debugging only!!!!

-	void					GetLRUHandleList( CUtlVector< memhandle_t >& list );

-	void					GetLockHandleList( CUtlVector< memhandle_t >& list );

-

-

-protected:

-	// derived class must call these to implement public API

-	unsigned short			CreateHandle( bool bCreateLocked );

-	memhandle_t				StoreResourceInHandle( unsigned short memoryIndex, void *pStore, unsigned int realSize );

-	void					*GetResource_NoLock( memhandle_t handle );

-	void					*GetResource_NoLockNoLRUTouch( memhandle_t handle );

-	void					*LockResource( memhandle_t handle );

-

-	// NOTE: you must call this from the destructor of the derived class! (will assert otherwise)

-	void					FreeAllLists()	{ FlushAll(); m_listsAreFreed = true; }

-

-							CDataManagerBase( unsigned int maxSize );

-	virtual					~CDataManagerBase();

-	

-	

-	inline unsigned int		MemTotal_Inline() const { return m_targetMemorySize; }

-	inline unsigned int		MemAvailable_Inline() const { return m_targetMemorySize - m_memUsed; }

-	inline unsigned int		MemUsed_Inline() const { return m_memUsed; }

-

-// Implemented by derived class:

-	virtual void			DestroyResourceStorage( void * ) = 0;

-	virtual unsigned int	GetRealSize( void * ) = 0;

-

-	memhandle_t				ToHandle( unsigned short index );

-	unsigned short			FromHandle( memhandle_t handle );

-	

-	void					TouchByIndex( unsigned short memoryIndex );

-	void *					GetForFreeByIndex( unsigned short memoryIndex );

-

-	// One of these is stored per active allocation

-	struct resource_lru_element_t

-	{

-		resource_lru_element_t()

-		{

-			lockCount = 0;

-			serial = 1;

-			pStore = 0;

-		}

-

-		unsigned short lockCount;

-		unsigned short serial;

-		void	*pStore;

-	};

-

-	unsigned int m_targetMemorySize;

-	unsigned int m_memUsed;

-	

-	CUtlMultiList< resource_lru_element_t, unsigned short >  m_memoryLists;

-	

-	unsigned short m_lruList;

-	unsigned short m_lockList;

-	unsigned short m_freeList;

-	unsigned short m_listsAreFreed : 1;

-	unsigned short m_unused : 15;

-

-};

-

-template< class STORAGE_TYPE, class CREATE_PARAMS, class LOCK_TYPE = STORAGE_TYPE *, class MUTEX_TYPE = CThreadNullMutex>

-class CDataManager : public CDataManagerBase

-{

-	typedef CDataManagerBase BaseClass;

-public:

-

-	CDataManager<STORAGE_TYPE, CREATE_PARAMS, LOCK_TYPE, MUTEX_TYPE>( unsigned int size = (unsigned)-1 ) : BaseClass(size) {}

-	

-

-	~CDataManager<STORAGE_TYPE, CREATE_PARAMS, LOCK_TYPE, MUTEX_TYPE>()

-	{

-		// NOTE: This must be called in all implementations of CDataManager

-		FreeAllLists();

-	}

-

-	// Use GetData() to translate pointer to LOCK_TYPE

-	LOCK_TYPE LockResource( memhandle_t hMem )

-	{

-		void *pLock = BaseClass::LockResource( hMem );

-		if ( pLock )

-		{

-			return StoragePointer(pLock)->GetData();

-		}

-

-		return NULL;

-	}

-

-	// Use GetData() to translate pointer to LOCK_TYPE

-	LOCK_TYPE GetResource_NoLock( memhandle_t hMem )

-	{

-		void *pLock = const_cast<void *>(BaseClass::GetResource_NoLock( hMem ));

-		if ( pLock )

-		{

-			return StoragePointer(pLock)->GetData();

-		}

-		return NULL;

-	}

-

-	// Use GetData() to translate pointer to LOCK_TYPE

-	// Doesn't touch the memory LRU

-	LOCK_TYPE GetResource_NoLockNoLRUTouch( memhandle_t hMem )

-	{

-		void *pLock = const_cast<void *>(BaseClass::GetResource_NoLockNoLRUTouch( hMem ));

-		if ( pLock )

-		{

-			return StoragePointer(pLock)->GetData();

-		}

-		return NULL;

-	}

-

-	// Wrapper to match implementation of allocation with typed storage & alloc params.

-	memhandle_t CreateResource( const CREATE_PARAMS &createParams, bool bCreateLocked = false )

-	{

-		BaseClass::EnsureCapacity(STORAGE_TYPE::EstimatedSize(createParams));

-		unsigned short memoryIndex = BaseClass::CreateHandle( bCreateLocked );

-		STORAGE_TYPE *pStore = STORAGE_TYPE::CreateResource( createParams );

-		return BaseClass::StoreResourceInHandle( memoryIndex, pStore, pStore->Size() );

-	}

-

-	// Iteration. Must lock first

-	memhandle_t GetFirstUnlocked()

-	{

-		unsigned node = m_memoryLists.Head(m_lruList);

-		if ( node == m_memoryLists.InvalidIndex() )

-		{

-			return INVALID_MEMHANDLE;

-		}

-		return ToHandle( node );

-	}

-

-	memhandle_t GetFirstLocked()

-	{

-		unsigned node = m_memoryLists.Head(m_lockList);

-		if ( node == m_memoryLists.InvalidIndex() )

-		{

-			return INVALID_MEMHANDLE;

-		}

-		return ToHandle( node );

-	}

-

-	memhandle_t GetNext( memhandle_t hPrev )

-	{

-		if ( hPrev == INVALID_MEMHANDLE )

-		{

-			return INVALID_MEMHANDLE;

-		}

-

-		unsigned short iNext = m_memoryLists.Next( FromHandle( hPrev ) );

-		if ( iNext == m_memoryLists.InvalidIndex() ) 

-		{

-			return INVALID_MEMHANDLE;

-		}

-

-		return ToHandle( iNext );

-	}

-

-	MUTEX_TYPE &AccessMutex()	{ return m_mutex; }

-	virtual void Lock() { m_mutex.Lock(); }

-	virtual bool TryLock() { return m_mutex.TryLock(); }

-	virtual void Unlock() { m_mutex.Unlock(); }

-

-private:

-	STORAGE_TYPE *StoragePointer( void *pMem )

-	{

-		return static_cast<STORAGE_TYPE *>(pMem);

-	}

-

-	virtual void DestroyResourceStorage( void *pStore )

-	{

-		StoragePointer(pStore)->DestroyResource();

-	}

-	

-	virtual unsigned int GetRealSize( void *pStore )

-	{

-		return StoragePointer(pStore)->Size();

-	}

-

-	MUTEX_TYPE m_mutex;

-};

-

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

-

-inline unsigned short CDataManagerBase::FromHandle( memhandle_t handle )

-{

-	unsigned int fullWord = (unsigned int)handle;

-	unsigned short serial = fullWord>>16;

-	unsigned short index = fullWord & 0xFFFF;

-	index--;

-	if ( m_memoryLists.IsValidIndex(index) && m_memoryLists[index].serial == serial )

-		return index;

-	return m_memoryLists.InvalidIndex();

-}

-

-inline int CDataManagerBase::LockCount( memhandle_t handle )

-{

-	Lock();

-	int result = 0;

-	unsigned short memoryIndex = FromHandle(handle);

-	if ( memoryIndex != m_memoryLists.InvalidIndex() )

-	{

-		result = m_memoryLists[memoryIndex].lockCount;

-	}

-	Unlock();

-	return result;

-}

-

-

-#endif // RESOURCEMANAGER_H

+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef RESOURCEMANAGER_H
+#define RESOURCEMANAGER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tier0/threadtools.h"
+#include "utlmultilist.h"
+#include "utlvector.h"
+
+FORWARD_DECLARE_HANDLE( memhandle_t );
+
+#define INVALID_MEMHANDLE ((memhandle_t)0xffffffff)
+
+class CDataManagerBase
+{
+public:
+
+	// public API
+	// -----------------------------------------------------------------------------
+	// memhandle_t			CreateResource( params ) // implemented by derived class
+	void					DestroyResource( memhandle_t handle );
+
+	// type-safe implementation in derived class
+	//void					*LockResource( memhandle_t handle );
+	int						UnlockResource( memhandle_t handle );
+	void					TouchResource( memhandle_t handle );
+	void					MarkAsStale( memhandle_t handle );		// move to head of LRU
+
+	int						LockCount( memhandle_t handle );
+	int						BreakLock( memhandle_t handle );
+	int						BreakAllLocks();
+
+	// HACKHACK: For convenience - offers no lock protection 
+	// type-safe implementation in derived class
+	//void					*GetResource_NoLock( memhandle_t handle );
+
+	unsigned int			TargetSize();
+	unsigned int			AvailableSize();
+	unsigned int			UsedSize();
+
+	void					NotifySizeChanged( memhandle_t handle, unsigned int oldSize, unsigned int newSize );
+
+	void					SetTargetSize( unsigned int targetSize );
+
+	// NOTE: flush is equivalent to Destroy
+	unsigned int			FlushAllUnlocked();
+	unsigned int			FlushToTargetSize();
+	unsigned int			FlushAll();
+	unsigned int			Purge( unsigned int nBytesToPurge );
+	unsigned int			EnsureCapacity( unsigned int size );
+
+	// Thread lock
+	virtual void			Lock() {}
+	virtual bool			TryLock() { return true; }
+	virtual void			Unlock() {}
+
+	// Iteration
+
+	// -----------------------------------------------------------------------------
+
+	// Debugging only!!!!
+	void					GetLRUHandleList( CUtlVector< memhandle_t >& list );
+	void					GetLockHandleList( CUtlVector< memhandle_t >& list );
+
+
+protected:
+	// derived class must call these to implement public API
+	unsigned short			CreateHandle( bool bCreateLocked );
+	memhandle_t				StoreResourceInHandle( unsigned short memoryIndex, void *pStore, unsigned int realSize );
+	void					*GetResource_NoLock( memhandle_t handle );
+	void					*GetResource_NoLockNoLRUTouch( memhandle_t handle );
+	void					*LockResource( memhandle_t handle );
+
+	// NOTE: you must call this from the destructor of the derived class! (will assert otherwise)
+	void					FreeAllLists()	{ FlushAll(); m_listsAreFreed = true; }
+
+							CDataManagerBase( unsigned int maxSize );
+	virtual					~CDataManagerBase();
+	
+	
+	inline unsigned int		MemTotal_Inline() const { return m_targetMemorySize; }
+	inline unsigned int		MemAvailable_Inline() const { return m_targetMemorySize - m_memUsed; }
+	inline unsigned int		MemUsed_Inline() const { return m_memUsed; }
+
+// Implemented by derived class:
+	virtual void			DestroyResourceStorage( void * ) = 0;
+	virtual unsigned int	GetRealSize( void * ) = 0;
+
+	memhandle_t				ToHandle( unsigned short index );
+	unsigned short			FromHandle( memhandle_t handle );
+	
+	void					TouchByIndex( unsigned short memoryIndex );
+	void *					GetForFreeByIndex( unsigned short memoryIndex );
+
+	// One of these is stored per active allocation
+	struct resource_lru_element_t
+	{
+		resource_lru_element_t()
+		{
+			lockCount = 0;
+			serial = 1;
+			pStore = 0;
+		}
+
+		unsigned short lockCount;
+		unsigned short serial;
+		void	*pStore;
+	};
+
+	unsigned int m_targetMemorySize;
+	unsigned int m_memUsed;
+	
+	CUtlMultiList< resource_lru_element_t, unsigned short >  m_memoryLists;
+	
+	unsigned short m_lruList;
+	unsigned short m_lockList;
+	unsigned short m_freeList;
+	unsigned short m_listsAreFreed : 1;
+	unsigned short m_unused : 15;
+
+};
+
+template< class STORAGE_TYPE, class CREATE_PARAMS, class LOCK_TYPE = STORAGE_TYPE *, class MUTEX_TYPE = CThreadNullMutex>
+class CDataManager : public CDataManagerBase
+{
+	typedef CDataManagerBase BaseClass;
+public:
+
+	CDataManager<STORAGE_TYPE, CREATE_PARAMS, LOCK_TYPE, MUTEX_TYPE>( unsigned int size = (unsigned)-1 ) : BaseClass(size) {}
+	
+
+	~CDataManager<STORAGE_TYPE, CREATE_PARAMS, LOCK_TYPE, MUTEX_TYPE>()
+	{
+		// NOTE: This must be called in all implementations of CDataManager
+		FreeAllLists();
+	}
+
+	// Use GetData() to translate pointer to LOCK_TYPE
+	LOCK_TYPE LockResource( memhandle_t hMem )
+	{
+		void *pLock = BaseClass::LockResource( hMem );
+		if ( pLock )
+		{
+			return StoragePointer(pLock)->GetData();
+		}
+
+		return NULL;
+	}
+
+	// Use GetData() to translate pointer to LOCK_TYPE
+	LOCK_TYPE GetResource_NoLock( memhandle_t hMem )
+	{
+		void *pLock = const_cast<void *>(BaseClass::GetResource_NoLock( hMem ));
+		if ( pLock )
+		{
+			return StoragePointer(pLock)->GetData();
+		}
+		return NULL;
+	}
+
+	// Use GetData() to translate pointer to LOCK_TYPE
+	// Doesn't touch the memory LRU
+	LOCK_TYPE GetResource_NoLockNoLRUTouch( memhandle_t hMem )
+	{
+		void *pLock = const_cast<void *>(BaseClass::GetResource_NoLockNoLRUTouch( hMem ));
+		if ( pLock )
+		{
+			return StoragePointer(pLock)->GetData();
+		}
+		return NULL;
+	}
+
+	// Wrapper to match implementation of allocation with typed storage & alloc params.
+	memhandle_t CreateResource( const CREATE_PARAMS &createParams, bool bCreateLocked = false )
+	{
+		BaseClass::EnsureCapacity(STORAGE_TYPE::EstimatedSize(createParams));
+		unsigned short memoryIndex = BaseClass::CreateHandle( bCreateLocked );
+		STORAGE_TYPE *pStore = STORAGE_TYPE::CreateResource( createParams );
+		return BaseClass::StoreResourceInHandle( memoryIndex, pStore, pStore->Size() );
+	}
+
+	// Iteration. Must lock first
+	memhandle_t GetFirstUnlocked()
+	{
+		unsigned node = m_memoryLists.Head(m_lruList);
+		if ( node == m_memoryLists.InvalidIndex() )
+		{
+			return INVALID_MEMHANDLE;
+		}
+		return ToHandle( node );
+	}
+
+	memhandle_t GetFirstLocked()
+	{
+		unsigned node = m_memoryLists.Head(m_lockList);
+		if ( node == m_memoryLists.InvalidIndex() )
+		{
+			return INVALID_MEMHANDLE;
+		}
+		return ToHandle( node );
+	}
+
+	memhandle_t GetNext( memhandle_t hPrev )
+	{
+		if ( hPrev == INVALID_MEMHANDLE )
+		{
+			return INVALID_MEMHANDLE;
+		}
+
+		unsigned short iNext = m_memoryLists.Next( FromHandle( hPrev ) );
+		if ( iNext == m_memoryLists.InvalidIndex() ) 
+		{
+			return INVALID_MEMHANDLE;
+		}
+
+		return ToHandle( iNext );
+	}
+
+	MUTEX_TYPE &AccessMutex()	{ return m_mutex; }
+	virtual void Lock() { m_mutex.Lock(); }
+	virtual bool TryLock() { return m_mutex.TryLock(); }
+	virtual void Unlock() { m_mutex.Unlock(); }
+
+private:
+	STORAGE_TYPE *StoragePointer( void *pMem )
+	{
+		return static_cast<STORAGE_TYPE *>(pMem);
+	}
+
+	virtual void DestroyResourceStorage( void *pStore )
+	{
+		StoragePointer(pStore)->DestroyResource();
+	}
+	
+	virtual unsigned int GetRealSize( void *pStore )
+	{
+		return StoragePointer(pStore)->Size();
+	}
+
+	MUTEX_TYPE m_mutex;
+};
+
+//-----------------------------------------------------------------------------
+
+inline unsigned short CDataManagerBase::FromHandle( memhandle_t handle )
+{
+	unsigned int fullWord = (unsigned int)handle;
+	unsigned short serial = fullWord>>16;
+	unsigned short index = fullWord & 0xFFFF;
+	index--;
+	if ( m_memoryLists.IsValidIndex(index) && m_memoryLists[index].serial == serial )
+		return index;
+	return m_memoryLists.InvalidIndex();
+}
+
+inline int CDataManagerBase::LockCount( memhandle_t handle )
+{
+	Lock();
+	int result = 0;
+	unsigned short memoryIndex = FromHandle(handle);
+	if ( memoryIndex != m_memoryLists.InvalidIndex() )
+	{
+		result = m_memoryLists[memoryIndex].lockCount;
+	}
+	Unlock();
+	return result;
+}
+
+
+#endif // RESOURCEMANAGER_H