// queue-stack.cc implementation file for 
// the Queue and Stack Class
#include<iostream.h>
#include<assert.h>
#include "queue-stack.h"

// constructor for Node class
Node::Node(int value)
{
  data = value;
  nextPtr = 0;
}

// implementation for Stack
Stack::Stack()
{
  outPtr = 0;
}
  
Stack::~Stack()
{
  if (!isEmpty())
    {
      Node* currentPtr = outPtr;
      Node* tempPtr;
      
      while (currentPtr != 0)
	{
	  tempPtr = currentPtr;
	  currentPtr = currentPtr -> nextPtr;
	  delete tempPtr;
	}
    }
}

int Stack::isEmpty() const
{
  if (outPtr == 0)
    return 1;
  else
    return 0;
}

void Stack::insert(const int value)
{
  Node *newPtr = getNewNode(value);

  if (isEmpty()) // empty
    {
     initSingleEle(newPtr);
    }
  else
    {
      newPtr ->nextPtr = outPtr;
      outPtr = newPtr;
    }
}

// removes a value from the Stack -- returns value
// through reference parameter value -- the return
// value of function is 1 if successful, 0 otherwise
int Stack::remove(int &value)
{
  if (isEmpty()) // list is empty
    return 0;     // delete unsuccessful
  else
    {
      Node* tempPtr = outPtr;
      
      if (outPtr -> nextPtr == 0) // single element list
	{
	  initNoElements();
	}
      else
	{
	  outPtr = outPtr -> nextPtr;
	  value = tempPtr -> data; // data returned
	  delete tempPtr;
	  return 1;               // delete successful
	}
    }
}

void Stack::print() const
{
  if (isEmpty())
    {
      cout << "The list is empty" << endl << endl;
      return;
    }
  Node* currentPtr = outPtr;
  cout << "The list is: ";
  
  while (currentPtr != 0)
    {
      cout << currentPtr -> data << " ";
      currentPtr = currentPtr -> nextPtr;
    }
  cout << endl << endl;
}

// return a pointer to a newly allocated Node  
Node* Stack::getNewNode(const int value)
{
  Node *ptr = new Node(value);

  assert(ptr != 0);
  return ptr;
}

// reset pointers for single element Stack
void Stack::initSingleEle(const Node * const ele)
{
  outPtr = ele;
}

// reset pointers for null Stack
void Stack::initNoElements()
{
  outPtr = 0;
}

// --------------------------------------------------
//        QUEUE CLASS
// --------------------------------------------------

Queue::Queue()
  : Stack()
{
  inPtr = 0;
}

Queue::~Queue()
{
}

void Queue::insert(const int value)
{
  Node *newPtr = getNewNode(value);

  if (isEmpty()) // empty
    {
     initSingleEle(newPtr);
    }
  else
    {
      inPtr -> nextPtr = newPtr;
      inPtr = newPtr;
    }
}

void Queue::initSingleEle(const Node* const ele)
{
  Stack::initSingleEle(ele);
  inPtr = ele;
}

void Queue::initNoElements()
{
  Stack::initNoElements();
  inPtr = 0;
}