//List class def

//programmer : MJO 2013'

//#include "datatype.h"

#include <stddef.h>

class List_
{

typedef struct Node_
{
DataT_ data_;
DataT_Key key_;

Node_ *next;
Node_ *prev;
}Node_;

private:

Node_ * list_;
Node_ * head_;
Node_ * tail_;
Node_ * Itorator_;

long size_;

public:
////////////////////////////////////////////////////////////////////////////////////////////////////
//construct/destruct//
List_();
~List_();
////////////////////////////////////////////////////////////////////////////////////////////////////
//stack function//
int Push(DataT_ );
DataT_ Pop();
DataT_ Top();
////////////////////////////////////////////////////////////////////////////////////////////////////
//list function//
int Insert(DataT_Key);
int Delete(DataT_Key);
////////////////////////////////////////////////////////////////////////////////////////////////////
//queue function//
int enQueue(DataT_ );
DataT_ deQueue();
////////////////////////////////////////////////////////////////////////////////////////////////////
//general function
int clear_list();
int HasNext();
int HasPrev();
Node_ * iBegin(); //return itorator_ = head
Node_ * iEnd(); //return itorator_ = tail
Node_ * gHead();
Node_ * gTail();
Node_ * gItorator();
Node_ * gNext();
Node_ * gPrev();
long Size();
DataT_ ShowData(Node_ *);
////////////////////////////////////////////////////////////////////////////////////////////////////
};//List_ class

////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////

//construct/destruct//
List_::List_()
{
list_ = NULL;
head_= NULL;
tail_= NULL;
Itorator_= NULL;
size_ = 0;
}

List_::~List_()
{
clear_list();
}

long List_::Size()
{
return size_;
}

//stack function//
int List_::Push(DataT_ input_)
{
if(list_ == NULL){
//start new list
list_ = new Node_;
list_->next = NULL;
list_->prev = NULL;
//set list addressing
head_ = list_;
tail_ = list_;
Itorator_ = list_;
list_->data_ = input_;
return ++size_;
//else push onto list STACK
}else{
head_->prev = new Node_;
Itorator_ = head_;
head_ = head_->prev;
head_->next = Itorator_;
Itorator_->prev = head_;
head_->prev = NULL;
head_->data_ = input_;
return ++size_;
}

}

DataT_ List_::Pop()
{
//pop head ,delete, fix addressing, return dataT
if(head_->next != NULL)
{
Itorator_ = head_;
head_ = head_->next;
DataT_ temp_ = Itorator_->data_;
delete Itorator_;
head_->prev = NULL;
--size_;
return temp_;
}
else
{
Itorator_ = head_;
DataT_ temp_ = Itorator_->data_;
delete Itorator_;
Itorator_ = NULL;
head_ = NULL;
tail_ = NULL;
list_ = NULL;
--size_;
return temp_;
}

}

DataT_ List_::Top()
{
Itorator_ = head_;
return Itorator_->data_;

}
//list function//
int List_::Insert(DataT_Key key_in)
{

return 0;

}
int List_::Delete(DataT_Key)
{
return 0;

}

//queue function//
int List_::enQueue(DataT_ input_)
{
if(list_ == NULL){

//start new list
list_ = new Node_;
list_->next = NULL;
list_->prev = NULL;
//set list addressing
head_ = list_;
tail_ = list_;
Itorator_ = list_;
list_->data_ = input_;
return ++size_;
}else{

head_->prev = new Node_;
Itorator_ = head_;
head_ = head_->prev;
head_->next = Itorator_;
Itorator_->prev = head_;
head_->prev = NULL;
head_->data_ = input_;
return ++size_;
}

}

DataT_ List_::deQueue()
{

if(tail_->prev != NULL)
{
Itorator_ = tail_;
DataT_ temp_ = Itorator_->data_;
tail_ = tail_->prev;
delete Itorator_;
tail_->next = NULL;
--size_;
return temp_;
}else{

Itorator_ = tail_;
DataT_ temp_ = Itorator_->data_;
delete Itorator_;
tail_ = NULL;
Itorator_ = NULL;
head_ = NULL;
list_ = NULL;
--size_;
return temp_;
}

}

List_::Node_* List_::gHead()
{
return head_;
}

List_::Node_* List_::gTail()
{
return tail_;
}

List_::Node_* List_::gItorator()
{
return Itorator_;
}

//general function
int List_::clear_list()
{
if(head_ == NULL) return -1; //had no list
static Node_ *temp_i;
if(temp_i == NULL) temp_i = head_;

if(temp_i->next != NULL){
Itorator_ = temp_i;
temp_i = temp_i->next;
delete Itorator_;
Itorator_ = NULL; --size_;
clear_list(); //call to clear again
}else{ //reached the end of the list
delete temp_i;
temp_i = NULL;
head_ = NULL;
tail_ = NULL;
list_ = NULL;
--size_;
}
return size_;//size would be zero
}

List_::Node_ * List_::iBegin()
{
return Itorator_ = head_;
}

List_::Node_ * List_::iEnd()
{
return Itorator_ = tail_;
}

List_::Node_ * List_::gNext()
{
return Itorator_ = (Itorator_->next == NULL ? NULL : Itorator_->next );
}
List_::Node_ * List_::gPrev()
{
return Itorator_ = (Itorator_->prev == NULL ? NULL : Itorator_->prev );
}

DataT_ List_::ShowData(List_::Node_ *in_pointer)
{
return in_pointer->data_;
}

int List_::HasNext()
{
return Itorator_->next == NULL ? 0: 1;
}
int List_::HasPrev()
{
return Itorator_->prev == NULL ? 0: 1;
}