#include<iostream>
#include<fstream>
using namespace std;
 
//	Node Declaration
	template <class  TYPE> 
	struct NODE
	  {
	   TYPE    data;
	   NODE   *link;
	  }; //  End of Node Declaration
 
//	List Class Declaration
 
	template <class  TYPE, class KTYPE> 
	class List  
	   {
	     private:
	       NODE<TYPE> *head;
	       NODE<TYPE> *pos;
	       NODE<TYPE> *rear;
	       int         count;
 
//	     Function Declarations
	       bool  _insert  (NODE<TYPE>   *pPre,   
	                       TYPE          dataIn);
	       void  _delete  (NODE<TYPE>   *pPre,
	                       NODE<TYPE>   *pLoc,
	                       TYPE         *dataOutPtr);
	       bool  _search  (NODE<TYPE>  **pPre,
	                       NODE<TYPE>  **pLoc,
	                       KTYPE         key);
 
	     public:
	       List (void);
	      ~List (void);
	       int        addNode      (TYPE   dataIn);
	       bool       removeNode   (KTYPE  key, 
	                                TYPE  *dataOutPtr);
	       bool       retrieveNode (KTYPE  Argu, 
	                                TYPE&  dataOut);
	       bool       getNext      (int    fromWhere,  
	                                TYPE&  dataOut);
	       int        listCount    (void);
	       bool       emptyList    (void);
	       bool       fullList     (void);
 
	   }; // class List 
 
// 	End of List Class Declaration
 
/* 	=============== List Constructor  ==============	
	Initialize the list.
	  Pre    Class is being instantiated
	  Post   Class instantiated and initialized
*/
template <class TYPE, class KTYPE>
List<TYPE, KTYPE> :: List (void)   
{
//	Statements 
	head     = NULL;
	pos      = NULL;
	rear     = NULL;
	count    = 0;
} //  List Constructor 
 
/*	==================== addNode =================== 
	Inserts data into linked list.
	   Pre     dataIn contains data to be inserted
	   Post    Data inserted or error
	   Return -1 if overflow, 
	           0 if successful,
	           1 if duplicate key
*/
template <class TYPE, class KTYPE> 
int List<TYPE, KTYPE> :: addNode (TYPE dataIn)
{
//	Local Definitions 
	bool  found;
	bool  success;
 
	NODE<TYPE>  *pPre;
	NODE<TYPE>  *pLoc;
 
//  Statements 
	found = _search (&pPre, &pLoc, dataIn.key);
	if (found)
	   // Duplicate keys not allowed 
	   return (+1);
 
	success = _insert (pPre,  dataIn);
	if (!success)
	   // Overflow 
	   return (-1);
	return (0);
}	//  addNode 
 
/*	===================== _insert ==================== 
	Inserts data into a new node in the linked list.
	   Pre     Insertion location identified by pPre
	           dataIn contains data to be inserted
	   Post    data inserted in linked list or overflow
	   Return  true  if successful, false if overflow
*/
template <class TYPE, class KTYPE>
bool List<TYPE, KTYPE> :: _insert (NODE<TYPE> *pPre,  
                                   TYPE        dataIn)
{
//	Local Definitions 
	NODE <TYPE>  *pNew;
 
//	Statements 
	if (! (pNew = new NODE<TYPE>))
	   return false;
 
	pNew->data = dataIn; 
	pNew->link = NULL; 
 
	if (pPre == NULL)
	   {
	    //  Adding before first node or to empty list. 
	    pNew->link = head;
	    head = pNew;
	   } // if pPre 
	else
	    {
	     // Adding in middle or at end 
	     pNew->link  = pPre->link;
	     pPre->link  = pNew;
	    } // if else  
 
	     // Now check for add at end of list 
	     if (pNew->link == NULL)
	        // Adding to empty list. Set rear  
	        rear = pNew;
 
	count++;
 
	return true;
}	// _insert 
 
/* 	================== removeNode ================== 
	Removes data from linked list. 
	   Pre    dltkey is identifier of node to be deleted
	          pDataOut is pointer to data variable to 
	          receive a copy of the deleted data
	   Post   data copied to output variable and node
	          deleted or not found
	   Return false if not found
	          true  if deleted
*/
template <class TYPE, class KTYPE>
bool List<TYPE, KTYPE> ::  
          removeNode (KTYPE dltkey, TYPE *pDataOut)
{
//	Local Definitions 
	bool         found;
	NODE<TYPE>  *pPre;
	NODE<TYPE>  *pLoc;
 
//	Statements 
	found = _search (&pPre, &pLoc, dltkey);
	if (found)
	    _delete (pPre, pLoc, pDataOut);
	return found;
} // removeNode
 
/*	=================== _delete ================== 
	Deletes data from a linked list and returns 
	data to calling module.
	   Pre  pPre is a pointer to predecessor node
	        pLoc is a pointer to target node
	        pDataOut is pointer to output data area
	   Post Data have been deleted and returned 
	        Data memory has been recycled
*/
template <class TYPE, class KTYPE>
void List<TYPE, KTYPE> :: _delete (NODE<TYPE>   *pPre,
                                   NODE<TYPE>   *pLoc, 
                                   TYPE         *pDataOut) 
{
//	Statements 
	*pDataOut = pLoc->data;
	if (pPre == NULL)
	    // Deleting first node 
	    head = pLoc->link;  
	else
	    // Deleting any other node
	    pPre->link = pLoc->link;
 
	// Test for deleting last node 
	if (pLoc->link == NULL)
	   rear = pPre;
 
	count--;
	delete pLoc;
 
	return;
}	//  _delete 
 
/*	=================== retrieveNode ================== 
	Interface to search function. 
	   Pre    key is the search argument
	          dataOut is variable to receive data
	   Post   dataOut contains located data if found
	          if not found, contents are unchanged
	   Return true if successful, false if not found
*/
 
template <class TYPE, class KTYPE>
bool List<TYPE, KTYPE> 
         :: retrieveNode (KTYPE  key, TYPE&  dataOut)
{
//	Local Definitions 
	bool          found;
	NODE <TYPE>  *pPre;
	NODE <TYPE>  *pLoc;
 
//	Statements 
	found = _search (&pPre, &pLoc, key);
	if (found)
	   dataOut = pLoc->data;
	return found;
}	// retrieveNode 
 
/*	==================== _search =================== 
	Searches list and passes back address of node 
	containing target and its logical predecessor.
	   Pre    pPre is pointer variable for predecessor
	          pLoc is pointer variable for found node
	          key  is search argument
	   Post   pLoc points to first node equal/greater key 
	          -or- null if target > key of last node
	          pPre points to largest node smaller than key
	          -or- null if target < key of first node
	   Return true if successful, false if not found
*/
template <class TYPE, class KTYPE> 
bool List<TYPE, KTYPE> :: _search (NODE<TYPE> **pPre,  
                                   NODE<TYPE> **pLoc,
                                   KTYPE        key)
{
//	Statements 
	*pPre  = NULL;
	*pLoc  = head;
	if (count == 0)
	    return false;
 
	// Test for argument > last node in list 
	if (key > rear->data.key) 
	   {
	    *pPre = rear;
	    *pLoc = NULL;
	    return false;
	   } // if 
 
	while (key > (*pLoc)->data.key)
	   {
	    //  Have not found search argument location 
	    *pPre = *pLoc;
	    *pLoc = (*pLoc)->link;
	   } // while 
 
	if (key == (*pLoc)->data.key)
	    //   argument found--success 
	    return true;
	else
	    return false;
}	//  _search 
 
/*	=============== emptyList ============== 
	Returns Boolean indicating whether the
	list is empty.
	   Pre    Nothing 
	   Return true if empty, false if list has data 
*/
template<class TYPE, class KTYPE> 
bool List<TYPE, KTYPE> :: emptyList (void) 
{
//	Statements 
 	return (count == 0);
}	//  emptyList 
 
/*	=================== fullList ================== 
	Returns Boolean indicating whether the list is full
	or has room for more data. 
	   Pre    Nothing 
	   Return true if full, false if room for another node
*/
template <class TYPE, class KTYPE>
bool List<TYPE, KTYPE> :: fullList (void) 
{
//	Local Definitions  
	NODE<TYPE>  *temp;
 
//	Statements 
	if (temp = new NODE<TYPE>)
	   {
	    delete temp;
	    return false;
	   } // if
 
	// Dynamic memory full 
	return true;
}	// fullList 
 
/*	==================== listCount ==================== 
	Returns integer representing number of nodes in list.
	   Pre     Nothing
	   Return  count for number of nodes in list
*/
template <class TYPE, class KTYPE>
int List<TYPE, KTYPE> :: listCount(void) 
{
//	Statements 
	return count;	
}	// listCount
 
/*	====================== getNext ===================== 
	getNext traverses a linked list. Each call either starts 
	at the beginning of the list or returns the location of  
	the element in the list that was last returned.
	   Pre   fromWhere is 0 to start at the first element
	         dataOut is reference to data variable 
	   Post   if another element, address placed in output area
	   Return true if another element located, 
	          false if end of list
*/
template <class TYPE, class KTYPE> 
bool List<TYPE, KTYPE> :: getNext (int    fromWhere,
                                   TYPE&  dataOut)
{
//	Local Definitions 
	bool success;
 
//	Statements 
	if (fromWhere == 0)
	   {
	    // Start from first node 
	    if (count == 0)
	        success = false;
	    else
	       {
	        pos      = head;
	        dataOut  = pos->data;
	        success  = true;
	       } // if else 
	   } // if fromwhere is zero
	else
	   {
	    // Continue from current position 
	    if (pos->link == NULL)
	        success = false;
	    else
	       {
	        pos      = pos->link;
	        dataOut  = pos->data;
	        success  = true;
	       } // if else 
	   } // if fromWhere else 
 
	return success;
}	// getNext
 
/*	=============== Destructor ============== 
	Deletes all data in list and recycles memory
	   Pre    List is being deleted 
	   Post   Data and class structure have been deleted
*/
template<class TYPE, class KTYPE> 
List<TYPE, KTYPE > :: ~List (void) 
{
//	Local Definitions 
	NODE<TYPE>   *deletePtr;
 
//	Statements 
	if (head)
	   {
	    while (count > 0) 
	       {
	        deletePtr = head;
	        head      = head->link; 
	        count--;
	        delete  deletePtr; 
	       } // while
	   } //  if 
}	// Destructor 
const int STR_MAX=100;
struct STUDENT
{
	int key;
	char name[STR_MAX];
	char level[STR_MAX];
};
/*	=============== instr ============== */
void instr(List<STUDENT,int>&list)
{
	STUDENT std;
	char ch;
	cout<<"DO you want to enter a new student(y/n)\n";
	cin>>ch;
	while (ch=='y')
	{
	cout<<"Enter the ID :"<<" ";
	cin>>std.key;
	cout<<"Enter the name:"<<" ";
	cin>>std.name;
	cout<<"Enter the level:"<<"  ";
	cin>>std.level;
  cout<<"DO you want to enter another student(y/n)\n";
	cin>>ch;
	}
	return;
}
 
/*	=============== buildList ============== */
 
void buildList (List<STUDENT,int>&list)
{
//local definitions
	ifstream Data;
	int addResult;
	STUDENT std;
	//statement
	Data.open("student.dat");
           if(!Data)
		   {
			   cerr<<"Error opening input file\n";
			   exit(1);
		   }//end if
		   while(Data>>std.key)
		   {
			   //insert into list
			   addResult=list.addNode (std);
				   if(addResult!= 0)
				   {
					   if(addResult== -1)
					   {
						   cout<<"memory over flow \n";
						   exit(-1);
					   }
					   else 
						   cout<<"ID:"
						   <<std.key
						   <<"not added\n";
		   }}
		   //end while
		   cout<<endl;
		   return;
}//buildList
 
 
/*	=============== printList ============== 
	PRINTS THE LIST
	   Pre    list has been created
	   Post   list printed
*/
void printList (List<STUDENT,int>&list)
{
STUDENT std;
if(list.listCount()==0)
 
cout<<"THE LIST IS EMPTY\n";
else
{
	list.getNext(0,std);
	do
	{
		cout<<std.key<<" "
			<<std.name<<" "
			<<std.level<<endl;
	}while (list.getNext(1,std));
	cout<<"end of the list"<<endl;
}//else
return;
}
 
 
 
/*	=============== getChoice ============== 
	PRINTS THE MENU OF CHOICES
	   Pre    nothing 
	   Post   menu printed and choice returned
*/
int getChoice() 
{
	int choice;
	bool valid;
 
	cout<<"***************MENU**********************"<<endl;
	cout<<" 1-	Build list from file\t"
         <<"2-	Build list from keyboard\t"
          <<"3-	Print list\n"
		  <<"4- exit"<<endl;
 
cout<<"ENTER YOUR CHOICE"<<endl;
do{
 
	cin>>choice;
	switch(choice)
	{
 
	case 1:
	case 2:
	case 3:
	case 4:
		valid=true;
		break;
	default:
		valid=false;
		cout<<"INVALID CHOICE TRY AGAIN"<<endl;
		break;
	}//switch
}while(!valid);
return choice;
}//getChoice
 
/*	=============== process ============== 
	PRINTS THE MENU OF CHOICES
	   Pre    list has been created
	   Post   all of user's choices executed
*/
void process (List<STUDENT,int>&list)
{
 
	int choice;
	do
	{
		choice=getChoice();
		switch(choice)
		{
		case 1:
			buildList(list);
			break;
		case 2:
		instr(list);
			break;
		case 3:
			printList(list);
			break;
		case 4:
			break;
		}//switch
	}while(choice!=4);
	return;
}//process
 
//prototype declarations
void instr (List<STUDENT,int>&list);
void printList(List<STUDENT,int>&list);
int getChoice (void);
void buildList (List<STUDENT,int>&list);
void process (List<STUDENT,int>&list);
 
int main()
{
	//local definitions
   List<STUDENT,int>list;
   //statement
 
   process(list);
   buildList(list);
   instr(list);
   printList(list);
   return 0;
}//MAIN