#ifndef __LEDSDATA_H__
#define __LEDSDATA_H__

#include "datalib.h"

// (Steve)
#include <iostream>
#include <fstream>
using namespace std;

#include <stdlib.h>


template <class compType>
class DataFileIter;

template <class compType>
class DataFile
{
//////////////////////////////////////////////////
// Friends
//
friend DataFileIter<compType>;
//////////////////////////////////////////////////
// Enumerated Types
//
//////////////////////////////////////////////////
// Initialization
//
public:
inline DataFile();
inline ~DataFile();
//inline VOID Init();
inline VOID Init(UINT_32 = 32);
inline VOID Expand(UINT_32);
inline DataFile<compType> *Copy();

//////////////////////////////////////////////////
// Input functions
//
public:
inline UINT_32 AddItem(const compType &item);
inline VOID SetNextItem(const compType &item);
//inline VOID SetCurrentIndex(UINT_32);
inline VOID Sort(int (*compar)(const void *, const void *));
//////////////////////////////////////////////////
// Output Functions
//
public:
inline VOID DisplayAll() const;
//////////////////////////////////////////////////
// Accessor Functions
//
public:
inline compType *GetCurrentItem();
inline compType *GetItem(UINT_32);
inline UINT_32 GetCurrentIndex() const;
inline UINT_32 GetSize() const;
inline compType *GetDataPtr() const;
//////////////////////////////////////////////////
// Class Variables
//

//////////////////////////////////////////////////
// Member Variables
//
protected:
UINT_32 m_uiSize;
UINT_32 m_uiCurrent;
compType *m_pTData;
};

template<class compType>
inline DataFile<compType>::DataFile()
{
  m_uiSize = 0;
  m_uiCurrent = 0;
  m_pTData = NULL;
}

template<class compType>
inline DataFile<compType>::~DataFile()
{
  delete [] m_pTData;
}
/*
template<class compType>
inline VOID DataFile<compType>::Init()
{ 
  m_uiSize = 0;
  m_uiCurrent = 0;
  m_pTData = NULL;
}
*/

template<class compType>
inline VOID DataFile<compType>::Init(UINT_32 uiSize)
{
  m_uiSize = uiSize;
  m_pTData = new compType[uiSize];
}


template<class compType>
inline DataFile<compType> *DataFile<compType>::Copy()
{
  DataFile<compType> *pCopy;
  UINT_32 i;

  pCopy = new DataFile<compType>;
  pCopy->Init(m_uiSize);

  for (i = 0; i < m_uiSize; i++) 
	{
	  pCopy->SetNextItem(m_pTData[i]);
	}

  return pCopy;
}

template<class compType>
inline VOID DataFile<compType>::Expand(UINT_32 uiNewSize)
{
  ASSERT (uiNewSize > m_uiSize);
  compType *pNewData;
  pNewData = new compType[uiNewSize];

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

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

template<class compType>
inline UINT_32 DataFile<compType>::AddItem(const compType &item)
{
  if (m_uiCurrent >= m_uiSize) {
	if (m_uiSize == 0)
	  m_uiSize = 1;
	Expand(2*m_uiSize);
  }

  m_pTData[m_uiCurrent] = item;
  return (m_uiCurrent++);

}

template<class compType>
inline VOID DataFile<compType>::SetNextItem(const compType &item)
{
  m_pTData[m_uiCurrent++] = item;
}

// I assume that Current is number actually written, which currently seems
// safe since I disabled SetCurrentIndex.
template<class compType>
inline VOID DataFile<compType>::
Sort(int (*compar)(const void *, const void *))
{
  qsort((void *)(m_pTData), m_uiCurrent, sizeof(compType), compar);
}

// We don't actually want anyone mucking with this
/*
template<class compType>
inline VOID DataFile<compType>::SetCurrentIndex(UINT_32 Index)
{
  m_uiCurrent = Index;
}
*/

template<class compType>
inline UINT_32 DataFile<compType>::GetCurrentIndex() const
{
  return m_uiCurrent;
}

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

template <class compType>
inline compType *DataFile<compType>::GetCurrentItem() 
{
  return &(m_pTData[m_uiCurrent - 1]);
}

template <class compType>
inline compType *DataFile<compType>::GetItem(UINT_32 Index) 
{
  if (Index < m_uiCurrent)
	return &(m_pTData[Index]);
  else
	return NULL;
}

template <class compType>
inline VOID DataFile<compType>::DisplayAll() const
{
  UINT_32 i;

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

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

template <class Type>
class DataFileIter
{
public:
  inline DataFileIter();
  inline ~DataFileIter();
  inline VOID Init(DataFile<Type> *pDataFile);

  //protected:
  inline VOID Uninit();
  inline BOOL Valid();

public:
  // Iteration Functions
  inline Type *PeekFirstItem();
  inline Type *PeekNextItem();
//  inline Type *PeekLastItem();
//  inline Type *PeekPrevItem();
  inline VOID BackUp();

protected:
  UINT_32 m_uiCurr;
  DataFile<Type> *m_pDataFile;
};

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

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

template<class Type>
inline VOID DataFileIter<Type>::Init(DataFile<Type> *pDataFile)
{
  m_pDataFile = pDataFile;
  m_uiCurr = 0;
}

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

template<class Type>
inline BOOL DataFileIter<Type>::Valid()
{
  if (!m_pDataFile)
	return FALSE;
  if ((m_uiCurr < m_pDataFile->GetCurrentIndex())
	  )//	  && (m_iCurr >= 0))
	return TRUE;
  else
  	return FALSE;
}

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

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

/*
template<class Type>
inline Type *DataFileIter<Type>::PeekLastItem()
{
  m_uiCurr = m_pDataFile->GetCurrentIndex() - 1;
  return m_pDataFile->GetItem(m_uiCurr--);
}

template<class Type>
inline Type *DataFileIter<Type>::PeekPrevItem()
{
    return m_pDataFile->GetItem(m_uiCurr--);
}
*/
template<class Type>
inline VOID DataFileIter<Type>::BackUp()
{
  m_uiCurr--;
}

// (compType = composite type)
// Have to declare compType separately instead of deriving it from 
// Types 1 & 2 so that inheritance for Triples will work
template <class compType, class Type1, class Type2>
class DataPairFile : public DataFile<compType>
{
//////////////////////////////////////////////////
// Initialization
//
public:
inline DataPairFile();
inline ~DataPairFile();
inline DataPairFile<compType,Type1,Type2> *Copy();

//////////////////////////////////////////////////
// Input functions
//

public:
inline VOID AddPair(Type1, Type2);
//inline VOID Sort(int (*compar)(const void *, const void *));
};


//////////////////////////////////////////////////////////////////////////////
// Inlined Functions
//

template<class compType, class Type1, class Type2>
inline DataPairFile<compType, Type1, Type2>::DataPairFile()
{
}

template<class compType, class Type1, class Type2>
inline DataPairFile<compType, Type1, Type2>::~DataPairFile()
{
}

template<class compType, class Type1, class Type2>
inline VOID DataPairFile<compType, Type1, Type2>::AddPair(Type1 First, Type2 Second){
  if (m_uiCurrent >= m_uiSize)
	Expand(2*m_uiSize);

  m_pTData[m_uiCurrent].SetFirst(First);
  m_pTData[m_uiCurrent++].SetSecond(Second);
}


template<class compType, class Type1, class Type2>
inline DataPairFile<compType, Type1, Type2> *DataPairFile<compType, Type1, Type2>::Copy()
{
  DataPairFile<compType, Type1, Type2> *pCopy;
  UINT_32 i;

  pCopy = new DataPairFile<compType, Type1, Type2>;
  pCopy->Init(m_uiSize);

  for (i = 0; i < m_uiSize; i++) 
	{
	  pCopy->SetNextItem(m_pTData[i]);
	}

  return pCopy;
}



template <class compType, class Type1, class Type2, class Type3>
class DataTripleFile : public DataPairFile<compType, Type1, Type2>
{
public:
  inline DataTripleFile();
  inline ~DataTripleFile();
  inline VOID AddTriple(Type1, Type2, Type3);
};

//////////////////////////////////////////////////////////////////////////////
// Inlined Functions
//


template<class compType, class Type1, class Type2, class Type3>
inline DataTripleFile<compType, Type1, Type2, Type3>::DataTripleFile()
{
}

template<class compType, class Type1, class Type2, class Type3>
inline DataTripleFile<compType, Type1, Type2, Type3>::~DataTripleFile()
{
}

template<class compType, class Type1, class Type2, class Type3>
inline VOID DataTripleFile<compType, Type1, Type2, Type3>::
AddTriple(Type1 First, Type2 Second, Type3 Third){

  if (m_uiCurrent >= m_uiSize)
	Expand(2*m_uiSize);

  m_pTData[m_uiCurrent].SetFirst(First);
  m_pTData[m_uiCurrent].SetSecond(Second);
  m_pTData[m_uiCurrent++].SetThird(Third);
}



#endif // __LEDSDATA_H__