#include <iostream>

#include <windows.h>
using namespace std;
template <class T>
class D_Node
{
public:
T element;
D_Node<T> *next_node;
D_Node<T> *prev_node;
D_Node(T = 0, D_Node * = NULL, D_Node * = NULL);

T retrieve() const;
D_Node<T> *next() const;
D_Node<T> *previous() const;
};
template <class T>
D_Node<T>::D_Node( T e, D_Node *n, D_Node *p) : element(e), next_node(n), prev_n
ode(p)
{
//Empty Constructor
}
template <class T>
T D_Node<T>::retrieve() const
{
return element;
}
template <class T>
D_Node<T> *D_Node<T>::next() const
{
return next_node;
}
template <class T>
D_Node<T> *D_Node<T>::previous() const
{
return prev_node;
}

template <class T>

class D_S_List
{
private:
D_Node<T> *list_head;
D_Node<T> *list_tail;
public:
//constructor
D_S_List();
//Accessors
bool empty() const;
int size() const;
T front() const;
T back() const;

D_Node<T> *head() const;

D_Node<T> *tail() const;
int count(T) const;
D_S_List<T> operator=(D_S_List<T> const&); //Operator Overloading
//Mutators
void push_front(T);
void push_back(T);
T pop_front();
T pop_back();
int erase(T);
void Display();
void Display_back();
};
template <class T>
D_S_List<T>::D_S_List():list_head(NULL),list_tail(NULL)
{
//Empty Contructor
}
template <class T>
bool D_S_List<T>::empty() const
{
return (list_head == NULL || list_tail == NULL);
}
template <class T>
int D_S_List<T>::size() const
{
int count = 0;
for (D_Node<T> *ptr = head(); ptr != NULL; ptr = ptr->next())
{
count++;
}
return count;
}
template <class T>
T D_S_List<T>::front() const
{
if (empty())
{
throw "underflow";
system("pause");
}
return head()->retrieve();
}
template <class T>
T D_S_List<T>::back() const
{
if (empty())
{
throw "underflow";
system("pause");

}
return tail()->retrieve();
}
template <class T>
D_Node<T> *D_S_List<T>::head() const
{
return list_head;
}
template <class T>
D_Node<T> *D_S_List<T>::tail() const
{
return list_tail;
}
template <class T>
int D_S_List<T>::count(T n) const
{
int node_count = 0;
for (D_Node<T> *ptr = head(); ptr != NULL; ptr = ptr->next())
{
if (ptr->retrieve() == n)
{
++node_count;
}
}
return node_count;
}
template<class T>
D_S_List<T> D_S_List<T>::operator=(D_S_List<T> const&l) //Operator Overl
oading
{
this->list_head=l.list_head;
return list_head;
}
template <class T>
void D_S_List<T>::push_front(T n)
{
if (size() == 0)
{
list_head = new D_Node<T>(n, head(), tail());
list_tail = list_head;
}
else
{
list_head = new D_Node<T>(n, head(), NULL);
(list_head->next_node)->prev_node = list_head;
}
}
template <class T>
void D_S_List<T>::push_back(T n)
{
list_tail = new D_Node<T>(n, NULL, tail());
(list_tail->prev_node)->next_node = tail();

}
template <class T>
T D_S_List<T>::pop_front()
{
if (empty())
{
throw "underflow";
system("pause");
}
T e = front();
D_Node<T> *ptr = list_head;
list_head = list_head->next();
delete ptr;
return e;
}
template <class T>
T D_S_List<T>::pop_back()
{
if (empty())
{
throw "underflow";
system("pause");
}
T e = front();
D_Node<T> *ptr = list_tail;
list_tail = list_tail->previous();
delete ptr;
return e;
}

template <class T>

int D_S_List<T>::erase(T n)
{
for (D_Node<T> *ptr = head(); ptr != NULL; ptr->next())
{
if (ptr->retrieve() == n)
{
D_Node<T> *ptr1 = ptr;
ptr = ptr->next();
delete ptr1;
}
}
return n;
}
template <class T>
void D_S_List<T>::Display()
{
D_Node<T> *ptr = head();

while (ptr != NULL)

{
cout << ptr->retrieve() << endl;
ptr = ptr->next();
}
delete ptr;
}
template <class T>
void D_S_List<T>::Display_back()
{
D_Node<T> * ptr = tail();
while (ptr != NULL)
{
cout << ptr->retrieve()<<endl;
ptr = ptr->previous();
}
}
int main()
{
D_S_List<int> list;
list.push_front(10);
list.push_front(1);
list.push_front(10);
list.push_front(63);
list.Display();
cout<<"\n\n\nGroup Members :\nWaqas Ahmad (150776)\n";
cout<<"Talha Latif (150784)\n";
return 0;
}