//----------------------------------------------------------------------------
//
//   FILE           :   queue.C
//   AUTHOR         :   Eugene Wallingford
//   CREATION DATE  :   April 1, 1997
//
//----------------------------------------------------------------------------
//
//   MODIFIED BY    :   
//   DATE           :   
//   DESCRIPTION    :   
//
//----------------------------------------------------------------------------

#include "queue.h"

//------------------------------------------------------------------------
// CLASS         :     QueueNode<QE>
// DESCRIPTION   :     Constructor
//------------------------------------------------------------------------

template <class QE>
QueueNode<QE>::QueueNode(QE element, QueueNode < QE > * successor)
{
   data = element;
   next = successor;
}

//------------------------------------------------------------------------
// CLASS         :     Queue<QE>
// DESCRIPTION   :     Constructor and Destructor
//------------------------------------------------------------------------

template <class QE>
Queue<QE>::Queue(int maxSize)
{
   QE              initial_value;
   QueueNode<QE> * temp;

   temp = new QueueNode<QE> (initial_value, 0);

   lastFree   = temp;
   lastFilled = temp;
   temp->next = temp;

   maxSize--;
   while (maxSize > 0)
   {
      temp = new QueueNode<QE> (initial_value, lastFilled->next);

      lastFilled->next = temp;
      lastFilled = temp;

      maxSize--;
   }

   lastFilled = lastFree;
}


template <class QE>
Queue<QE>::~Queue()
{
   QueueNode<QE> * start = lastFilled->next;
   lastFilled->next      = 0;

   while (start != 0)
   {
      lastFilled = start;
      start = start->next;
      delete lastFilled;
   }

   lastFilled = 0;
   lastFree   = 0;
}

//------------------------------------------------------------------------
// CLASS         :     Queue<QE>
// DESCRIPTION   :     Query Messages
//------------------------------------------------------------------------

template <class QE>
int Queue<QE>::isEmpty()
{
   // return true if the queue is empty, that is,
   // if front is the same as rear

   return lastFilled == lastFree;
}


template <class QE>
int Queue<QE>::isFull()
{
   // return true if the queue is full, that is,
   // if there is only one free slot

   return lastFilled->next == lastFree;
}

//------------------------------------------------------------------------
// CLASS         :     Queue<QE>
// DESCRIPTION   :     Manipulation Messages
//------------------------------------------------------------------------

template < class QE >
QE Queue < QE >::dequeue()
{
   // advance front of queue, return value of element at the front
   lastFree = lastFree->next;
   return lastFree->data;
}


template <class QE>
QE Queue<QE>::front()
{
   // return value of element at the front
   return lastFree->next->data;
}



template <class QE>
void Queue<QE>::enqueue(QE e)
{
   if (lastFilled->next == lastFree)
   {
      QueueNode<QE> * temp = new QueueNode<QE>(e, lastFilled->next);

      lastFilled->next = temp;
      lastFilled       = temp;
   }
   else
   {
      lastFilled       = lastFilled->next;
      lastFilled->data = e;
   }
}

// END OF FILE