#ifndef __LL_QUEUE_HPP__
#define __LL_QUEUE_HPP__

#include <cassert>

template <typename T>
class node
{
public:
	T data;
	node<T>* next;

	node() { next = NULL; }
	node(T elem) { data = elem;  next = NULL; }
};

template <typename T>
class LL_Queue
{
private:
	node<T>* front, * rear;
public:
	LL_Queue() { front = rear = NULL; }
	LL_Queue(T elem) { node<T>* newNode = new node<T>(elem); front = rear = newNode; }
	LL_Queue(const LL_Queue<T>& q2);	// copy constructor
	~LL_Queue();

	bool isEmpty() { return front == NULL;}
	bool isFull();

	void enqueue(T elem);
	T dequeue();

};

template <typename T>
bool LL_Queue<T>::isFull()
{
	//T elem;
	node<T>* newNode = new node<T>();
	if (newNode == NULL)
		return true;
	delete newNode;
	return false;
}

template <typename T>
void LL_Queue<T>::enqueue(T elem)
{
	assert(!isFull());
	
	node<T>* newNode = new node<T>(elem);

	// the queue is empty
	if (front == NULL)
	{
		front = rear = newNode;
	}
	else
	{
		rear->next = newNode;
		rear = newNode;
	}
}

template <typename T>
T LL_Queue<T>::dequeue()
{
	assert(!isEmpty());

	T rlt = front->data;

	node<T>* tmp = front;

	front = front->next;

	if (front == NULL)
	{
		// after dequeue, the queue is empty
		front = rear = NULL;
	}
	delete tmp;

	return rlt;
}

// copy constructor
template <typename T>
LL_Queue<T>::LL_Queue(const LL_Queue<T>& q2)
{
	front = rear = NULL;
	node<T>* tmp = q2.front;

	while (tmp != NULL)
	{
		node<T>* newNode = new node<T>(tmp->data);
		if (front == NULL)
		{
			front = rear = newNode;
		}
		else
		{
			rear->next = newNode;
			rear = newNode;
		}

		tmp = tmp->next;
	}
}

template <typename T>
LL_Queue<T>::~LL_Queue()
{
	node<T>* tmp;

	while (front != NULL)
	{
		tmp = front;
		front = front->next;
		delete tmp;
	}
}


#endif