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

// Author: Julie Petrusa (991339)                                             //

// Program 2, Due date: February 13, 2001                                     //

// The class CLList implements a circular linked list                         //

// Fields: head, tail, current, and size                                      //

// Methods: - isEmpty, which checks if the list is empty                      //

//          - firstInsert, which inserts a new node as the first node into    //

//                         the sofar empty list                               //   

//          - addAfter, which adds a new node after the current node          //

//          - remove, which removes the node pointed to by current            //

//          - lookup, which determines if a node is in the list or not        //

//          - start, which sets the current pointer to the starting node and  //

//                   returns the node that current points to                  //

//          - node, which returns the node that current points to             //

//          - advance, which advances the current pointer n steps             //

//          - length, which returns the number of items in the list           //

//          - printToFile, which cycles through the list and prints the data  //

//                         content of the list items                          // 

// Known bugs: None                                                           //

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

import java.io.*;  // needed in order to do io

                   // this allows you to use the classes for reading file input

class CLList

      {

      //------------------------------------------------------------------------ 

      // fields 

            private Listnode head;     // starting point of the list

            private Listnode tail;     // ending point of the list

            private Listnode current;  // current item in the list 

            private int size;          // number of items in the list 

      //------------------------------------------------------------------------ 

      // constructor

      // -initialize the list as null 

      // -initialize current as null 

      // -initialize the size as 0           

      	   public CLList()

              {

              head = null;        // no items on list yet

              tail = null;     

              current = null;  

              size = 0;        

              }

      //------------------------------------------------------------------------

      // method isEmpty

      // -checks if the list is empty

      	   public boolean isEmpty()

	      {

	      return head == null;  // true if no nodes

	      }                

      //------------------------------------------------------------------------

      // method firstInsert

      // -creates a new node with ob as its data

      // -inserts that node as first node into the sofar empty list

      // -updates current to the new node and increments size

            public void firstInsert(Object ob)

               {

               Listnode newNode = new Listnode(ob);  // make new node

               if(isEmpty())			     // if empty list,

                  tail = newNode;		     // newNode <-- tail

	       else                                  // if not empty list,

                  head.previous = newNode;	     // newNode <-- old head

               newNode.next = head; 		     // newNode --> old head

	       head = newNode;                       // head --> newNode

	       current = newNode;                    // current --> newNode

               size++;                               // increment size

               }

      //------------------------------------------------------------------------

      // method addAfter                  

      // -creates a new node with stuff as its data 

      // -adds the new node after the current node 

      // -doesn't work if list is empty, print a message 

      // -current afterwards points to the new node 

      // -updates size 

            public void addAfter(Object stuff) 

               {

               Listnode newNode = new Listnode(stuff);  // make new node

               if(isEmpty())                            // if empty list,

                  {                                     // print message

                  System.out.println();

                  System.out.println("The list is empty!");

		  }

               if(current == tail)                 // if last node,

                  {

		  newNode.next = null;             // newNode --> null

		  tail = newNode;                  // newNode <-- tail

		  }

	       else                                // not last node,

		  {

		  newNode.next = current.next;     // newNode --> old next

		  current.next.previous = newNode; // newNode <-- old next

		  }

	       newNode.previous = current;         // old current <-- newNode

	       current.next = newNode;             // old current --> newNode

               current = newNode;                  // current --> newNode

               size++;                             // increment size

               }

      //------------------------------------------------------------------------

      // method remove

      // -removes the node pointed to by current 

      // -after that, current points to the node after the removed node 

      // -if the only node in the list is removed, current will be null 

      //  and the list will be null as well 

      // -if the list is empty, prints a message 

      // -updates size 

            public void remove()

               {

               if(isEmpty())                  // if empty list,

                  {                           // print message

                  System.out.println();

                  System.out.println("The list is empty!");

		  }

               if(current == head)            // if first node,

		  head = current.next;        // head --> old next

	       else

		  current.previous.next = current.next;      // not first,

                                              // old previous --> old next

               if(current == tail)

                  {                           // if last node,

                  tail = current.previous;    // old previous <-- tail

		  current = current.previous; // current --> old previous

		  }

	       else                           // not last,

		  {                           // old previous <-- old next

                  current.next.previous = current.previous;

		  current = current.next;     // current --> old next

		  }

               size--;                        // increment size

               }

      //------------------------------------------------------------------------

      // method lookup

      // -cycles through the list and compares stuff with the data field of the 

      //  current Listnode  

      // -if the stuff was found in the list, returns true, 

      //  otherwise returns false 

            public boolean lookup(Object stuff)

               {

               boolean value = true;             // initialize

               Listnode probe = head;            // point to first node

               while( (!(probe.data.equals(stuff))) && (value) )

                  {                // while stuff not found and not end of list,

		  probe = probe.next;            // point to next node

		  if(probe == null)              // if end of list,

                  value = false;                 // stuff was not found    

   	          }

	       return value;	                 // only true if found

               }

      //------------------------------------------------------------------------

      // method start

      // -sets the current pointer to the starting node 

      // -returns the node that current points to 

      // -if list is empty, prints a message that list is empty 

            public Listnode start() 

               { 

               current = head;         // current points to first node

               if(isEmpty())           // if empty list, print message

                  System.out.println("The list is empty!"); 

               return current;         // returns the new current

               } 

      //------------------------------------------------------------------------

      // method node

      // -returns the node that current points to 

      // -if list is empty, prints a message 

            public Listnode node() 

               {

               if(isEmpty())           // if empty list, print message

                  System.out.println("The list is empty!"); 

               return current;         // returns node pointed to by current

               } 

      //------------------------------------------------------------------------

      // method advance

      // -advances the current pointer n steps 

      // -if list is empty, prints a message 

            public void advance(int n) 

               {

               if(isEmpty())                  // if empty list, print message

                  System.out.println("The list is empty!");

               for(int i=0; i<n; i++)         // repeat n times                     

                  {

                  if(current.next == null)    // if end of list,

                     current = head;          // wrap around

                  else                        // if not end,

           	     current = current.next;  // advance one step		                  

                  }

               }

      //------------------------------------------------------------------------ 

      // method length

      // -returns the number of items in the list 

            public int length() 

               { 

               return size; 

               } 

      //------------------------------------------------------------------------

      // method printToFile

      // -cycles through the list  

      // -via PrintWriter p prints the data content of the list items 

            public void printToFile(PrintWriter p) 

               {

               Listnode temp = head;       // point to first node

               while(temp != null)         // while not end of list,

                  {

	          p.println(temp.data);    // print the data in output file

		  temp = temp.next;        // point to the next node

		  }

               }

      //------------------------------------------------------------------------

      }  // end class CLList





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

// Author: Julie Petrusa (991339)                                             //

// Program 2, Due date: February 13, 2001                                     //

// The class Listnode creates the object Listnode                             //

// Fields: data, previous, and next                                           //

// Methods: None                                                              //                                                        

// Known bugs: None                                                           //

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

class Listnode 

      {

      //------------------------------------------------------------------------

      // fields, note that we don't set the access qualifiers.  The reason is  

      // that we want to grant CLList access to the fields of Listnode.

            Object data;        // data item

            Listnode previous;  // previous node in list  

            Listnode next;      // next node in list

      //------------------------------------------------------------------------           

      // constructor

      // -initialize data, previous, and next to given quantities

            public Listnode(Object stuff, Listnode n, Listnode p)

               {

               data = stuff;

               previous = p;

               next = n;

               }

      //------------------------------------------------------------------------

      // constructor

      // -initialize data to a given quantity

      // -initialize previous and next to null           

            public Listnode(Object stuff)

               {

               data = stuff;

               previous = null;

               next = null;

               } 

      //------------------------------------------------------------------------

      // constructor

      // -initialize data, previous, and next to null                                                            

            public Listnode()

               {

               data = null;

               previous = null;

               next = null;

               }

      //------------------------------------------------------------------------

      // method toString

      // -converts the fields in the object Employee to a string ready

      //  for printing via a PrintWriter

            public String toString()

               {

               return data.toString();

               } 

      //------------------------------------------------------------------------

      }  // end class Listnode

      



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

// Author: Julie Petrusa (991339)                                             //

// Program 2, Due date: February 13, 2001                                     //

// The class Employee represents the object in the data field of Listnode     //                          

// Fields: name and id number                                                 //

// Methods: - readFrom, which reads data from a DataInputStream               // 

//          - equals, which tests if a given object is of type Employee       //

//                    and agrees with the calling object field by field       //

//          - toString, which converts the Employee object to a string,       //

//                      thus preparing it for file output.                    //                                                        

// Known bugs: None                                                           //

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

class Employee

      {

      //------------------------------------------------------------------------

      // fields 

            private int id;

            private String name;

      //------------------------------------------------------------------------

      // constructor

      // -initialize id to zero

      // -initialize name to null

            public Employee() 

               { 

               id = 0;

               name = null;

               }

      //------------------------------------------------------------------------

      // constructor

      // -initialize id and name to given quantities

            public Employee(int ID, String Name)

               { 

               id = ID;

               name = Name;                  

               }         

      //------------------------------------------------------------------------ 

      // method readFrom

      // -reads form an input file via a BufferedReader

      // -it will throw an IOException, if the file does not exist or 

      //  you try to read beyond the end 

      // -the id number will first be read as a string and then be converted 

      //  to an integer 

      // -Integer is a wrapper class of int 

      	   public void readFrom(BufferedReader in) throws IOException

              { 

              String IDstr = in.readLine(); 

              id = Integer.parseInt(IDstr); 

              name = in.readLine(); 

              }  

      //------------------------------------------------------------------------

      // method equals

      // -checks if the object ob is an instance of the Employee class

      // -if the outcome is positive, checks if there is field by field equality

      //  between the calling object (the this reference) and the object ob

            public boolean equals(Object ob)

               {

	       // check that ob is actually an Employee object

	       if (!(ob instanceof Employee))

	          return false;

                                     

	       // cast ob to an Employee type

	       Employee emp = (Employee) ob;

                       

	       // return true if there is field by field equality

	       return ((id == emp.id) && (name.equals(emp.name)));

               }

      //------------------------------------------------------------------------

      // method toString

      // -converts the fields in the object Employee to a string ready

      //  for printing via a PrintWriter

            public String toString()

               {

               return (name +"\n"+ id +"\n");

               }

      //------------------------------------------------------------------------

      }  // end class Employee





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

// Author: Julie Petrusa (991339)                                             //

// Program 2, Due date: February 13, 2001                                     //

// The class Rolodex tests the rolodex                                        //

// Fields: none                                                               //

// Methods: - main, the driver, which sets up the io files and tests the      //

//                              classes Listnode, CLList, and Employee        //

// Known bugs: None                                                           //

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

public class Rolodex

   {

   public static void main(String[] args)

      {

      try

         {

         String myInName;  // name of input file

         BufferedReader in;

         myInName = "inputFile.txt";

         File inFile = new File(myInName);

         in = new BufferedReader(new FileReader(inFile));



         String myOutName;  // name of output file

         PrintWriter p;

         myOutName = "outputFile.txt";

         File outFile = new File(myOutName);

         p = new PrintWriter(new BufferedWriter(new FileWriter(outFile)));



         //************************************************************

         // print banner

         p.println("Author: Julie Petrusa (991339)");

         p.println("Program 2, Due date: February 13, 2001");

         p.println("This program simulates a Rolodex");

         //************************************************************



         //************************************************************

         // test rolodex



         // create a new list

         CLList myList = new CLList();



         // create a new employee

         Employee newest = new Employee(7621, "Pablo Picasso");

	                      

	 // insert newest employee at beginning of new list

         myList.firstInsert(newest);

                          

	 // look up an employee

         p.println(" ");

         p.print(newest);

         if(myList.lookup(newest))

            p.println(" is in the list");

         else

            p.println(" is not in the list");  



         // add all employees from input file to the list

         Employee empone = new Employee();

         empone.readFrom(in);

         myList.addAfter(empone);

                        

         Employee emptwo = new Employee();

         emptwo.readFrom(in);

         myList.addAfter(emptwo);     

                        

         Employee empthree = new Employee();

         empthree.readFrom(in);

         myList.addAfter(empthree);

                        

         // remove current

         myList.remove();                   

		                

	 // let current point to the beginning of the list

	 myList.start();



         // advance 10 steps

         myList.advance(10);     



         // find out what current points to

         p.println(" ");

         p.print("CURRENT points to: ");

	 p.println(myList.node());



         // find out the size of the list

         p.println(" ");

         p.print("Size = ");

         p.println(myList.length());



         // display the entire list

         p.println(" ");

         p.println("List: ");

         myList.printToFile(p);            

         //************************************************************



         p.flush();

         in.close();

         p.close();

         }  // end try



      catch (IOException e)

         {

         System.out.println("IOException");

         }  // end catch



      }  // end main

   }  // end class Rolodex