#ifndef __CIRCOBJECTLIST_H__
#define __CIRCOBJECTLIST_H__

#include "genlib.h"

// This was adapted from Jordan's object lists which actually put the sentinel
// node into the list.  I want to be able to splice pieces of circular lists
// together without having to worry about having just one sentinel node in
// the resulting list(s), and to be able to get the next or previous link
// quickly without having to skip over sentinel nodes.
//
// Given all that, it would probably be more efficient (and the code would
// perhaps be clearer) if I dropped the sentinel node and just had two
// ptrs to the "head" and "tail" of the circular list.

//////////////////////////////////////////////////////////////////////////////
// CCircularList Class
//

template <class TLink>
class CCircObjectListIter;

template <class TLink>
class CCircObjectList
{
public:
  friend class CCircObjectListIter<TLink>;

public:
  inline CCircObjectList();
  inline ~CCircObjectList();
  inline BOOL Init();
  inline BOOL Init(TLink *);

protected:
  inline VOID Uninit();
  inline BOOL Initialized() const;
  inline BOOL Valid() const;

public:
  // Insertion Functions

  inline VOID InsertFirst(TLink *pLink);
  inline VOID InsertLast(TLink *pLink);
  inline VOID InsertNext(TLink *pLinkBase, TLink *pLink);
  inline VOID InsertPrev(TLink *pLinkBase, TLink *pLink);

//  inline VOID SpliceNext(TLink *pLinkBase, CCircObjectList *pList);
//  inline VOID SplicePrev(TLink *pLinkBase, CCircObjectList *pList);

  // Deletion Functions

  inline VOID Remove(TLink *pLink);
  inline TLink *RemoveFirst();
  inline TLink *RemoveLast();
  inline TLink *RemoveNext(TLink *pLink);
  inline TLink *RemovePrev(TLink *pLink);
  inline BOOL RemoveAll();

  // Look up Functions

  inline TLink *PeekFirst() const;
  inline TLink *PeekLast() const;
  inline TLink *PeekNext(TLink *pLink) const;
  inline TLink *PeekPrev(TLink *pLink) const;

  // Display Functions
  inline VOID Display();

public:
protected:
  TLink m_linkSentinel;
  TLink *m_pHead;
  TLink *m_pTail; // This is the same Sentinal Node as the Head 
};


//////////////////////////////////////////////////////////////////////////////
// Class Implementations
//

// CCircObjectList Class
//

template <class TLink>
inline BOOL CCircObjectList<TLink>::Initialized() const
{
  return ((m_pHead != NULL) &&
		  (m_pTail != NULL));
}

template <class TLink>
inline BOOL CCircObjectList<TLink>::Valid() const
{
  return (Initialized() && 
		  (m_pHead == m_pTail));
}

template <class TLink>
inline CCircObjectList<TLink>::CCircObjectList()
{
  RemoveAll();
}

template <class TLink>
inline CCircObjectList<TLink>::~CCircObjectList()
{
  Uninit();
}


template <class TLink>
inline BOOL CCircObjectList<TLink>::Init()
{
  ASSERT( m_pHead == &m_linkSentinel );
  ASSERT( m_pTail == &m_linkSentinel );
  ASSERT( m_pHead->GetNextLink() == m_pTail );
  ASSERT( m_pTail->GetPrevLink() == m_pHead );

  ASSERT( Valid() );

  return TRUE;
}


template <class TLink>
inline BOOL CCircObjectList<TLink>::Init(TLink *pLink)
{
  ASSERT( m_pHead == &m_linkSentinel );
  ASSERT( m_pTail == &m_linkSentinel );

  m_pHead->SetNext(pLink);
  m_pHead->SetPrev(pLink->GetPrev());


  ASSERT( Valid() );

  return TRUE;
}

template <class TLink>
inline BOOL CCircObjectList<TLink>::RemoveAll()
{
  m_pHead =  &m_linkSentinel;
  m_pTail = &m_linkSentinel;
  m_pHead->SetNext(m_pHead);
  m_pHead->SetPrev(m_pHead);

  return TRUE;
}

template <class TLink>
inline VOID CCircObjectList<TLink>::Uninit()
{
  RemoveAll();
}

template <class TLink>
inline VOID CCircObjectList<TLink>::InsertFirst(TLink *pLink)
{
  InsertNext(m_pHead, pLink);
}

template <class TLink>
inline VOID CCircObjectList<TLink>::InsertLast(TLink *pLink)
{
  InsertPrev(m_pTail, pLink);
}

template <class TLink>
inline TLink *CCircObjectList<TLink>::RemoveFirst()
{
  return RemoveNext(m_pHead);
}

template <class TLink>
inline TLink *CCircObjectList<TLink>::RemoveLast()
{
  return RemovePrev(m_pTail);
}

template <class TLink>
inline TLink *CCircObjectList<TLink>::PeekFirst() const
{
  return PeekNext(m_pHead);
}

template <class TLink>
inline TLink *CCircObjectList<TLink>::PeekLast() const
{
  return PeekPrev(m_pTail);
}

template <class TLink>
inline TLink *CCircObjectList<TLink>::PeekNext(TLink *pLink) const
{
  ASSERT( pLink != NULL );

  return (pLink->GetNext());
}

template <class TLink>
inline TLink *CCircObjectList<TLink>::PeekPrev(TLink *pLink) const
{
  ASSERT( pLink != NULL );

  return (pLink->GetPrev());
}

template <class TLink>
inline VOID CCircObjectList<TLink>::Display()
{
  ASSERT( Valid() );
  
  TLink *pCurr;

  for ( pCurr = m_pHead; pCurr->GetNext() != m_pTail; pCurr = pCurr->GetNext() )
    {
      if ( pCurr == m_pHead )
	{
	  printf("(HEAD)->");
	}
      pCurr->GetNext()->Display();
      printf("->");
      if ( m_pTail == pCurr->GetNext() )
	{
	  printf("<-(TAIL)");
	}
    }
  printf("\n");
}

template <class TLink>
inline VOID CCircObjectList<TLink>::InsertNext(TLink *pCurr, TLink *pCLink)
{
  ASSERT( Initialized() ); 
  ASSERT( pCurr != NULL && pCLink != NULL );

  if ((pCurr == m_pHead) && ((pCurr->GetNext()) == pCurr)) {
	pCLink->SetNext(pCLink);
	pCLink->SetPrev(pCLink);
  }
  else if (pCurr == m_pHead) {
	pCLink->SetNext(pCurr->GetNext());
	pCLink->SetPrev(pCurr->GetPrev());
	pCurr->GetPrev()->SetNext(pCLink);
  }
  else {
	pCLink->SetNext(pCurr->GetNext());
	pCLink->SetPrev(pCurr);
  }

  pCurr->GetNext()->SetPrev(pCLink);
  pCurr->SetNext(pCLink);

  ASSERT( Valid() );
}

template <class TLink>
inline TLink *CCircObjectList<TLink>::RemoveNext(TLink *pCurr)
{
  ASSERT( Valid() ); 
  ASSERT( pCurr != NULL );

  TLink *pCLink;

  pCLink = pCurr->GetNext();

  // list is empty
  if ( pCLink == m_pTail )
    {
      return NULL;
    }
  // only one elt in list
  else if ( pCLink == pCLink->GetPrev() )
	{
	  m_pTail->SetNext(m_pTail);
	  m_pTail->SetPrev(m_pTail);
	}
  // Removing first elt in list
  else if ( pCurr == m_pTail)
	{
	  pCurr->SetNext(pCLink->GetNext());
	  pCurr->GetNext()->SetPrev(pCLink->GetPrev());
	  pCLink->GetPrev()->SetNext(pCLink->GetNext());
	}
  else
	{
	  pCurr->SetNext(pCLink->GetNext());
	  pCurr->GetNext()->SetPrev(pCurr);
	}

  return pCLink;
}

template <class TLink>
inline VOID CCircObjectList<TLink>::InsertPrev(TLink *pCurr, TLink *pCLink)
{
  ASSERT( Initialized() ); 
  ASSERT( pCurr != NULL && pCLink != NULL );

  if ((pCurr == m_pHead) && ((pCurr->GetNext()) == pCurr)) {
	pCLink->SetNext(pCLink);
	pCLink->SetPrev(pCLink);
  }
  else if (pCurr == m_pHead) {
	pCLink->SetNext(pCurr->GetNext());
	pCLink->SetPrev(pCurr->GetPrev());
	pCurr->GetNext()->SetPrev(pCLink);
  }
  else {
	pCLink->SetPrev(pCurr->GetPrev());
	pCLink->SetNext(pCurr);
  }

  pCurr->GetPrev()->SetNext(pCLink);
  pCurr->SetPrev(pCLink);

  ASSERT( Valid() );
}

template <class TLink>
inline TLink *CCircObjectList<TLink>::RemovePrev(TLink *pCurr)
{
  ASSERT( Valid() ); 
  ASSERT( pCurr != NULL );

  TLink *pCLink;

  pCLink = pCurr->GetPrev();
  // list is empty
  if ( pCLink == m_pTail )
    {
      return NULL;
    }
  // only one elt in list
  else if ( pCLink == pCLink->GetPrev())
	{
	  m_pTail->SetNext(m_pTail);
	  m_pTail->SetPrev(m_pTail);
	}
  // Removing last elt in list
  else if ( pCurr == m_pTail)
	{
	  pCurr->SetPrev(pCLink->GetPrev());
	  pCurr->GetPrev()->SetNext(pCLink->GetNext());
	  pCLink->GetNext()->SetPrev(pCLink->GetPrev());
	}
  else
	{
	  pCurr->SetPrev(pCLink->GetPrev());
	  pCurr->GetPrev()->SetNext(pCurr);
	}
  

  return pCLink;
}

/*
template <class TLink>
inline VOID CCircObjectList<TLink>::
SpliceNext(TLink *pLinkBase, CCircObjectList *pList)
{
}

template <class TLink>
inline VOID CCircObjectList<TLink>::
SplicePrev(TLink *pLinkBase, CCircObjectList *pList)
{
}
*/

//////////////////////////////////////////////////////////////////////////////
// CCircObjectListIter Class
//

template <class TLink>
class CCircObjectListIter
{
public:
  inline CCircObjectListIter();
  inline ~CCircObjectListIter();
  inline BOOL Init(CCircObjectList<TLink> *pCCircObjectList);

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

public:
  inline VOID SetCurr(TLink *);

  // Iteration Functions
  inline TLink *PeekFirst();
  inline TLink *PeekNext();
  inline TLink *PeekLast();
  inline TLink *PeekPrev();

protected:
  CCircObjectList<TLink> *m_pCCircObjectList;
  TLink *m_pCurr;
};

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


//////////////////////////////////////////////////////////////////////////////
// CCircObjectListIter Class
//

template <class TLink>
inline CCircObjectListIter<TLink>::CCircObjectListIter()
{
  m_pCCircObjectList = NULL;
  m_pCurr = NULL;
}

template <class TLink>
inline CCircObjectListIter<TLink>::~CCircObjectListIter()
{
  Uninit();
}

template <class TLink>
inline BOOL CCircObjectListIter<TLink>::Init(CCircObjectList<TLink> *pCCircObjectList)
{
  ASSERT( pCCircObjectList != NULL );

  m_pCCircObjectList = pCCircObjectList;
//  m_pCurr = m_pCCircObjectList->PeekFirst();

  return TRUE;
}

template <class TLink>
inline VOID CCircObjectListIter<TLink>::Uninit()
{
  m_pCCircObjectList = NULL;
  m_pCurr = NULL;
}

template <class TLink>
inline BOOL CCircObjectListIter<TLink>::Valid()
{
  return (m_pCCircObjectList != NULL);
}

template <class TLink>
inline VOID CCircObjectListIter<TLink>::SetCurr(TLink *pCurr)
{
  m_pCurr = pCurr;
}

template <class TLink>
inline TLink *CCircObjectListIter<TLink>::PeekFirst()
{
  ASSERT( Valid() ); 

  m_pCurr = m_pCCircObjectList->m_pHead->GetNext();
  if ( m_pCurr == m_pCCircObjectList->m_pTail )
    {
      m_pCurr = NULL;
    }

  return m_pCurr;
}

template <class TLink>
inline TLink *CCircObjectListIter<TLink>::PeekNext()
{
  ASSERT( Valid() ); 

  if ( m_pCurr == NULL )
    {
      return NULL;
    }

  m_pCurr = m_pCurr->GetNext();

  return m_pCurr;
}

template <class TLink>
inline TLink *CCircObjectListIter<TLink>::PeekLast()
{
  ASSERT( Valid() );

  m_pCurr = m_pCCircObjectList->m_pTail->GetPrev();
  if ( m_pCurr == m_pCCircObjectList->m_pHead )
    {
      m_pCurr = NULL;
    }

  return m_pCurr;
}

template <class TLink>
inline TLink *CCircObjectListIter<TLink>::PeekPrev()
{
  ASSERT( Valid() );

  if ( m_pCurr == NULL )
    {
      return NULL;
    }

  m_pCurr = m_pCurr->GetPrev();
  return m_pCurr;
}


#endif // __CIRCOBJECTLIST_H__