#ifndef STRUCTURE_H
#define STRUCTURE_H

template < class T >
class CTypedPtrArray
{
protected:
	T **m_pHead;
	int m_iSize;
	int m_iTail;
public:
	CTypedPtrArray( void );
	~CTypedPtrArray( void );

	bool IsEmpty( void ) const { return m_iTail == 0; }
	int GetSize( void ) const { return m_iTail; }
	int GetTrueSize( void ) const { return m_iSize; }
	void SetTailAt( const int i ) { m_iTail = i; }
	bool IsIndexValid( const int i ) { return ( i >= 0 ) && ( i < m_iTail ); }

	void SetSize( int );
	int AddTail( T * );
	bool RemoveTail( void );
	void RemoveAll( void );
	bool SetAt( int, T * );

	T *&operator[] ( const int index ) { return m_pHead[index]; }
	void FreePtrs( void );
};

template < class T >
CTypedPtrArray< T >::CTypedPtrArray( void )
{
	m_pHead = NULL;
	m_iSize = 0;
	m_iTail = 0;
}

template < class T >
CTypedPtrArray< T >::~CTypedPtrArray( void )
{
	if ( m_pHead )
		delete[] m_pHead;
}

template < class T >
void CTypedPtrArray< T >::SetSize( int size )
{
	if ( size == 0 )
	{ 
		RemoveAll();
		return;
	}

	T **oldArray = m_pHead;
	int oldSize = m_iSize;

	m_iSize = size;
	if ( m_iTail > m_iSize )
		m_iTail = m_iSize;
	m_pHead = new T*[m_iSize];
	memset( m_pHead, NULL, sizeof( T * ) * m_iSize );

	if ( oldSize )
	{
		if ( m_iTail )
			memcpy( m_pHead, oldArray, sizeof( T * ) * m_iTail );
		delete[] oldArray;
	}
}

template < class T >
int CTypedPtrArray< T >::AddTail( T *t )
{	
	if ( m_iTail == m_iSize )
		SetSize( m_iSize ? m_iSize << 1 : 1 );

	m_pHead[m_iTail] = t;
	int index = m_iTail;
	m_iTail++;
	return index;
}

template < class T >
bool CTypedPtrArray< T >::RemoveTail( void )
{
	if ( IsEmpty() )
		return false;

	m_iTail--;
	delete m_pHead[m_iTail];
	m_pHead[m_iTail] = NULL;
	if ( m_iTail <= ( m_iSize >> 2 ) )
		SetSize( m_iSize >> 1 );
	return true;
}

template < class T >
void CTypedPtrArray< T >::RemoveAll( void )
{
	if ( m_pHead )
	{
		FreePtrs( );
		delete[] m_pHead;
		m_pHead = NULL;
		m_iSize = 0;
		m_iTail = 0;
	}
}

template < class T >
bool CTypedPtrArray< T >::SetAt( int index, T *t )
{
	if ( IsIndexValid( index ) )
	{
		m_pHead[index] = t;
		return true;	
	}
	else
		return false;
}

template < class T >
void CTypedPtrArray< T >::FreePtrs( void )
{
	int i;
	T **t = m_pHead;
	for ( i = 0; i < m_iSize; i++ )
	{
		if ( *t )
		{ 
			delete *t;
			*t = NULL;
		}
		t++;
	}
}

#endif