//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================//

#ifndef ENTITYDATAINSTANTIATOR_H
#define ENTITYDATAINSTANTIATOR_H
#ifdef _WIN32
#pragma once
#endif

#include "utlhash.h"

#include "tier0/memdbgon.h"

// This is the hash key type, but it could just as easily be and int or void *
class CBaseEntity;

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
abstract_class IEntityDataInstantiator
{
public:
	virtual ~IEntityDataInstantiator() {};

	virtual void *GetDataObject( const CBaseEntity *instance ) = 0;
	virtual void *CreateDataObject( const CBaseEntity *instance ) = 0;
	virtual void DestroyDataObject( const CBaseEntity *instance ) = 0;
};

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
template <class T>
class CEntityDataInstantiator : public IEntityDataInstantiator
{
public:
	CEntityDataInstantiator() : 
		m_HashTable( 64, 0, 0, CompareFunc, KeyFunc )
	{
	}

	virtual void *GetDataObject( const CBaseEntity *instance )
	{
		UtlHashHandle_t handle; 
		HashEntry entry;
		entry.key = instance;
		handle = m_HashTable.Find( entry );

		if ( handle != m_HashTable.InvalidHandle() )
		{
			return (void *)m_HashTable[ handle ].data;
		}

		return NULL;
	}

	virtual void *CreateDataObject( const CBaseEntity *instance )
	{
		UtlHashHandle_t handle; 
		HashEntry entry;
		entry.key = instance;
		handle = m_HashTable.Find( entry );

		// Create it if not already present
		if ( handle == m_HashTable.InvalidHandle() )
		{
			handle = m_HashTable.Insert( entry );
			Assert( handle != m_HashTable.InvalidHandle() );
			m_HashTable[ handle ].data = new T;
	
			// FIXME: We'll have to remove this if any objects we instance have vtables!!!
			Q_memset( m_HashTable[ handle ].data, 0, sizeof( T ) );
		}

		return (void *)m_HashTable[ handle ].data;
	}

	virtual void DestroyDataObject( const CBaseEntity *instance )
	{
		UtlHashHandle_t handle; 
		HashEntry entry;
		entry.key = instance;
		handle = m_HashTable.Find( entry );

		if ( handle != m_HashTable.InvalidHandle() )
		{
			delete m_HashTable[ handle ].data;
			m_HashTable.Remove( handle );
		}
	}

private:

	struct HashEntry
	{
		HashEntry()
		{
			key = NULL;
			data = NULL;
		}

		const CBaseEntity *key;
		T				*data;
	};

	static bool CompareFunc( const HashEntry &src1, const HashEntry &src2 )
	{
		return ( src1.key == src2.key );
	}


	static unsigned int KeyFunc( const HashEntry &src )
	{
		// Shift right to get rid of alignment bits and border the struct on a 16 byte boundary
		return (unsigned int)src.key;
	}

	CUtlHash< HashEntry >	m_HashTable;
};

#include "tier0/memdbgoff.h"

#endif // ENTITYDATAINSTANTIATOR_H
