#ifndef QUEUETP_H_
	#define QUEUETP_H_

	template <typename Type>
	class QueueTP
	{
	private:
		struct Node { Type item; struct Node * next;};
		enum {Q_SIZE = 10};
	//Private class members
		Node * front;
		Node * rear;
		int items;
		const int qsize;
	//Preemptive definitions tro prevent public copying
		QueueTP(const QueueTP & q) : qsize(0) { }
		QueueTP & operator=(const QueueTP & q){return *this;}
	public:
		explicit QueueTP(int qs = Q_SIZE) : qsize(qs), front(NULL), rear(NULL), items(0) {};
		~QueueTP();
		bool isempty() const;
		bool isfull() const;
		int queuecount() const;
		bool enqueue(const Type &item);
		bool dequeue(Type &item);
	};
	#endif

template <typename Type>
QueueTP<typename Type>::~QueueTP()
{
	Node * temp;
	while (front != NULL)
	{
		temp = front;
		front = front->next;
		delete temp;
	}
}

template <typename Type>
bool QueueTP<typename Type>::isempty() const
{
	return items == 0;
}

template <typename Type>
bool QueueTP<typename Type>::isfull() const
{
	return items == qsize;
}

template <typename Type>
int QueueTP<typename Type>::queuecount() const
{
	return items;
}

template <typename Type>
bool QueueTP<typename Type>::enqueue(const Type & item)
{
	if (isfull())
		return false;
	Node * add = new Node;
	if (add == NULL)
		return false;
	add->item = item;
	add->next = NULL;
	items++;
	if (front == NULL)
		front = add;
	else
		rear->next = add;
	rear = add;
	return true;
}

template <typename Type>
bool QueueTP<typename Type>::dequeue(Type & item)
{
	if (front == NULL)
		return false;
	item = front->item;
	items--;
	Node * temp = front;
	front = front->next;
	delete temp;
	if (items == 0)
		rear = NULL;
	return true;
}