#ifndef __DYNAMICARRAY_H__
#define __DYNAMICARRAY_H__

// This should really be called "GrowableArray" because it
// only grows, it doesn't shrink.

#include "genlib.h"

template <class Type>
class CDynamicArrayIter;

template <class Type>
class CDynamicArray
{
//////////////////////////////////////////////////
// Friends
//
friend class CDynamicArrayIter<Type>;
//////////////////////////////////////////////////
// Enumerated Types
//
//////////////////////////////////////////////////
// Initialization
//
public:
inline CDynamicArray();
inline ~CDynamicArray();
inline VOID Init();
inline VOID Init(UINT_32);
inline VOID Init(UINT_32, Type *);
VOID Expand(UINT_32);

//////////////////////////////////////////////////
// Input functions
//
public:
inline VOID AddItemToEnd(Type item);
inline VOID AddItem(Type item, UINT_32 index);
inline VOID SetLastIndex(UINT_32);
inline VOID Sort(int (*compar)(const void *, const void *));
//////////////////////////////////////////////////
// Output Functions
//
public:
inline VOID DisplayAll() const;
//////////////////////////////////////////////////
// Accessor Functions
//
public:
inline Type *GetItem(UINT_32);
inline UINT_32 GetLastIndex() const;
inline UINT_32 GetSize() const;
inline Type *GetDataPtr() const;
//////////////////////////////////////////////////
// Class Variables
//

//////////////////////////////////////////////////
// Member Variables
//
protected:
UINT_32 m_uiSize;
UINT_32 m_uiLast;
Type *m_pTData;
};

template<class Type>
inline CDynamicArray<Type>::CDynamicArray()
{
  m_uiSize = 0;
  m_uiLast = 0;
  m_pTData = NULL;
}

template<class Type>
inline CDynamicArray<Type>::~CDynamicArray()
{
  delete [] m_pTData;
}

template<class Type>
inline VOID CDynamicArray<Type>::Init()
{ 
  m_uiSize = 0;
  m_uiLast = 0;
  m_pTData = NULL;
}

template<class Type>
inline VOID CDynamicArray<Type>::Init(UINT_32 uiSize)
{
  ASSERT (uiSize > 0);
  m_uiSize = uiSize;
  m_pTData = new Type[uiSize];

  UINT_32 i;
  for (i=0; i < uiSize; i++) {
        m_pTData[i] = NULL;
  }
}

template<class Type>
inline VOID CDynamicArray<Type>::Init(UINT_32 uiSize, Type *array)
{
  m_uiSize = uiSize;
  m_pTData = array;
  m_uiLast = uiSize;
}

template<class Type>
inline VOID CDynamicArray<Type>::Expand(UINT_32 uiNewSize)
{
  // We hope that we started with a size > 0, or standard practice
  // of doubling it will make this assertion fail (as it should)
  ASSERT (uiNewSize > m_uiSize);
  Type *pNewData;
  pNewData = new Type[uiNewSize];

  // Is there some block copy we could use?   
  UINT_32 i;
  for (i = 0; i < m_uiSize; i++) 
	{
	  pNewData[i] = m_pTData[i];
	}
  for (i = m_uiSize; i < uiNewSize; i++) 
	{
	  pNewData[i] = NULL;
	}

  delete [] m_pTData;
  m_pTData = pNewData;
  m_uiSize = uiNewSize;
}

template<class Type>
inline VOID CDynamicArray<Type>::AddItem(Type item, UINT_32 index)
{
  if (index >= m_uiSize)
	Expand(2*index);

  m_pTData[index] = item;

  if (index > m_uiLast)
	m_uiLast = index;
}

template<class Type>
inline VOID CDynamicArray<Type>::AddItemToEnd(Type item)
{
  if (m_uiLast >= m_uiSize)
	Expand(2*m_uiSize);

  m_pTData[m_uiLast++] = item;

}

// I assume that Last is number actually written (i.e. that no one
// has called setLast to change it).
template<class Type>
inline VOID CDynamicArray<Type>::
Sort(int (*compar)(const void *, const void *))
{
  qsort((void *)(m_pTData), m_uiLast, sizeof(Type), compar);
}

template<class Type>
inline VOID CDynamicArray<Type>::SetLastIndex(UINT_32 Index)
{
  m_uiLast = Index;
}

template<class Type>
inline UINT_32 CDynamicArray<Type>::GetLastIndex() const
{
  return m_uiLast;
}

template<class Type>
inline UINT_32 CDynamicArray<Type>::GetSize() const
{
  return m_uiSize;
}

template <class Type>
inline Type *CDynamicArray<Type>::GetItem(UINT_32 Index) 
{
  if (Index >= m_uiSize)
	Expand(2*Index);

  return &(m_pTData[Index]);
}

template <class Type>
inline VOID CDynamicArray<Type>::DisplayAll() const
{
  UINT_32 i;

  for (i = 0; i < m_uiLast; i++) {
	cout << m_pTData[i] << "\n";
  }
}

template <class Type>
inline Type *CDynamicArray<Type>::GetDataPtr() const
{
  return (m_pTData);
}


template <class Type>
class CDynamicArrayIter
{
public:
  inline CDynamicArrayIter();
  inline ~CDynamicArrayIter();
  inline VOID Init(CDynamicArray<Type> *pCDynamicArray);
  inline VOID Uninit();
  inline BOOL Valid();

public:
  // Iteration Functions
  inline Type *PeekFirstItem();
  inline Type *PeekNextItem();

protected:
  UINT_32 m_uiCurr;
  CDynamicArray<Type> *m_pCDynamicArray;
};

template<class Type>
inline CDynamicArrayIter<Type>::CDynamicArrayIter()
{
  m_uiCurr = 0;
  m_pCDynamicArray = NULL;
}

template<class Type>
inline CDynamicArrayIter<Type>::~CDynamicArrayIter()
{
}

template<class Type>
inline VOID CDynamicArrayIter<Type>::Init(CDynamicArray<Type> *pCDynamicArray)
{
  m_pCDynamicArray = pCDynamicArray;
  m_uiCurr = 0;
}

template<class Type>
inline VOID CDynamicArrayIter<Type>::Uninit()
{
}

template<class Type>
inline BOOL CDynamicArrayIter<Type>::Valid()
{
  if (!m_pCDynamicArray)
	return FALSE;
  if (m_uiCurr < m_pCDynamicArray->GetLastIndex())
	return TRUE;
  else
  	return FALSE;
}

template<class Type>
inline Type *CDynamicArrayIter<Type>::PeekFirstItem()
{
  m_uiCurr = 0;
  return m_pCDynamicArray->GetItem(m_uiCurr);
}

template<class Type>
inline Type *CDynamicArrayIter<Type>::PeekNextItem()
{
  return m_pCDynamicArray->GetItem(m_uiCurr++);
}

#endif // __DYNAMICARRAY_H__