/*****************************************
 * Instructions
 *  - Replace 'uwuserid' with your uWaterloo User ID
 *  - Select the current calendar term and enter the year
 *  - List students with whom you had discussions and who helped you
 *
 * uWaterloo User ID:  uwuserid @uwaterloo.ca
 * Submitted for ECE 250
 * Department of Electrical and Computer Engineering
 * University of Waterloo
 * Calender Term of Submission:  (Winter|Spring|Fall) 201N
 *
 * By submitting this file, I affirm that
 * I am the author of all modifications to
 * the provided code.
 *
 * The following is a list of uWaterloo User IDs of those students
 * I had discussions with in preparing this project:
 *    -
 *
 * The following is a list of uWaterloo User IDs of those students
 * who helped me with this project (describe their help; e.g., debugging):
 *    -
 *****************************************/

#ifndef DEQUE_H
#define DEQUE_H

#ifndef nullptr
#define nullptr 0
#endif

#include <algorithm>
#include "Exception.h"

template <typename Type>
class Deque {
	private:
		int array_capacity;
		Type *array;
		int ihead;
		int itail;
		int entry_count;

	public:
		Deque( int = 10 );
		Deque( Deque const & );
		~Deque();

		Type head() const;
		Type tail() const;
		int size() const;
		bool empty() const;
		int capacity() const;

		void swap( Deque & );
		Deque &operator=( Deque const & );
		void enqueue_head( Type const & );
		void enqueue_tail( Type const & );
		Type dequeue_head();
		Type dequeue_tail();
		void clear();

	// Friends

	template <typename T>
	friend std::ostream &operator<<( std::ostream &, Deque<T> const & );
};

template <typename Type>
Deque<Type>::Deque( int n ):
array_capacity( std::max( 1, n ) ),
array( new Type[array_capacity] ),
entry_count( 0 ) {
	// empty
}

template <typename Type>
Deque<Type>::~Deque() {
	// Enter your implementation here.
}

template <typename Type>
Deque<Type>::Deque( Deque const &deque ):
array_capacity( deque.array_capacity ),
array( new Type[array_capacity] ),
ihead( deque.ihead ),
itail( deque.itail ),
entry_count( deque.entry_count ) {
	// The above initializations copy the values of the appropriate
	// member variables and allocate memory for the data structure;
	// however, you must still copy the stored objects.

	// Enter your implementation here.
}

template <typename Type>
int Deque<Type>::size() const {
	// Enter your implementation here.
	return 0;
}

template <typename Type>
int Deque<Type>::capacity() const {
	return array_capacity;
}

template <typename Type>
bool Deque<Type>::empty() const {
	// Enter your implementation here.
	return true;
}

template <typename  Type>
Type Deque<Type>::head() const {
	// Enter your implementation here.
	return Type();     // This returns a default object
}

template <typename  Type>
Type Deque<Type>::tail() const {
	// Enter your implementation here.
	return Type();     // This returns a default object
}

template <typename Type>
void Deque<Type>::swap( Deque<Type> &queue ) {
	std::swap( array_capacity, queue.array_capacity );
	std::swap( array, queue.array );
	std::swap( ihead, queue.ihead );
	std::swap( itail, queue.itail );
	std::swap( entry_count, queue.entry_count );
}

template <typename Type>
Deque<Type> &Deque<Type>::operator=( Deque<Type> const &rhs ) {
	Deque<Type> copy( rhs );

	swap( copy );

	return *this;
}

template <typename Type>
void Deque<Type>::enqueue_head( Type const &obj ) {
	// Enter your implementation here.
}

template <typename Type>
void Deque<Type>::enqueue_tail( Type const &obj ) {
	// Enter your implementation here.
}

template <typename Type>
Type Deque<Type>::dequeue_head() {
	// Enter your implementation here.
	return Type();     // This returns a default object
}

template <typename Type>
Type Deque<Type>::dequeue_tail() {
	// Enter your implementation here.
	return Type();     // This returns a default object
}

template <typename Type>
void Deque<Type>::clear() {
	// Enter your implementation here.
}

// You can modify this function however you want:  it will not be tested

template <typename Type>
std::ostream &operator<<( std::ostream &out, Deque<Type> const &deque ) {
	// Print out your stacks

	return out;
}

// Is an error showing up in ece250.h or elsewhere?
// Did you forget a closing '}' ?

#endif