package project2Final;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/**
* Creates and updates multiple queues from list of Presidents
*
* @author Matthew Ramsay
* @since 2016-09-24
*/
public class Main
{
/**
* Creates and updates multiple queues from list of Presidents
*
*
* @param args the command line arguments
* @return Returns nothing
*/
public static void main(String[] args) throws IOException
{
Queue presidentsQueue = new Queue();
// creates 2 file IO objects to read in text from document
FileIO presReader = new FileIO("Presidents.txt", 44);
FileIO presUpdateReader = new FileIO("PresidentUpdate.txt", 8);
// reads all lines from text file and stores in presReader object
presReader.readPresidents();
// removes each president from presReader object and inserts into queue
while (presReader.presRemaining())
presidentsQueue.insert(presReader.getNextPresident());
presidentsQueue.displayQueues();
presidentsQueue.selectionSortAll();
presidentsQueue.displaySortedQueues();
// reads all lines from text file and stores in presUpdateReader object
presUpdateReader.readPresidents();
// displays the updated presidents read in
presUpdateReader.showNewPres();
// removes each president from presUpdateReader object and inserts into
queue

// removes each president from presUpdateReader object and inserts into

queue
while (presUpdateReader.presRemaining())
presidentsQueue.priorityInsert(presUpdateReader.getNextPresident());
presidentsQueue.displayPriorityQueue();
} // end main()
} // end Main

package project2Final;

/**
* Creates and Defines Presidents objects including attributes and operations
*
* @author Matthew Ramsay
* @since 2016-09-24
*/
public class Presidents
{
private int number;
private String name, party;

/**
* Constructor for Presidents object
*
* @param number : integer
* @param name : String
* @param party : String
* @return Returns nothing
*/
public Presidents(int number, String name,
String party)
{
this.number = number;
this.name = name;
this.party = party;
} // end Presidents() <constructor>

/**
* Gets the current number of Presidents object.
*

* @param none
* @return Number of Presidents object
*/
public int getNumber()
{
return number;
}// end getNumber()

/**
* Assigns parameter as number attribute of Presidents object.
*
* @param newNumber : integer
* @return Returns nothing
*/
public void setNumber(int newNumber)
{
number = newNumber;
} // end setNumber()

/**
* Gets the current name of Presidents object.
*
* @param none
* @return Name of Presidents object
*/
public String getName()
{
return name;
} // end getName()

/**
* Assigns parameter as name attribute of Presidents object.
*
* @param newName : String
* @return Returns nothing
*/
public void setName(String newName)
{
name = newName;
} // end newName()

/**
* Gets the current party of Presidents object.
*

* @param none
* @return Party of Presidents object
*/
public String getParty()
{
return party;
} // end getParty()

/**
* Assigns parameter as party attribute of Presidents object.
*
* @param newParty : String
* @return Returns nothing
*/
public void setParty(String newParty)
{
party = newParty;
} // end setParty()

/**
* Prints a string representation of key attributes of Presidents objects.
*
* @param none
* @return Returns nothing
*/
public String toString()
{
return
(String.format("%6d %-21s%s", number, name, party));
} // end toString()
} // end Presidents

package project2Final;
import java.util.ArrayList;
/**
* "Class description"
*
* @author Matthew Ramsay

* @since 2016-09-24
*/
public class Queue
{
private ArrayList<Presidents> queueDem;
private ArrayList<Presidents> queueRep;
private ArrayList<Presidents> queueWhig;
private int frontDem, frontRep, frontWhig, rearDem, rearRep, rearWhig;
private int demElems, repElems, whigElems;

/**
* Description of method
*
* @param none
* @return Returns nothing
*/
public Queue() // constructor
{
queueRep = new ArrayList<Presidents>();
queueDem = new ArrayList<Presidents>();
queueWhig = new ArrayList<Presidents>();
frontDem = 0;
frontRep = 0;
frontWhig = 0;
rearDem = -1;
rearRep = -1;
rearWhig = -1;
demElems = 0;
repElems = 0;
whigElems = 0;
}

/**
* Inserts Presidents object into queue base on party
*
* @param tempPres : Presidents
* @return Returns nothing
*/
public void insert(Presidents tempPres) // change parameter names
{
String partyQ = tempPres.getParty();
switch(partyQ)
{
case "Democrat":
queueDem.add(++rearDem, tempPres);

demElems++;
break;
case "Republican":
queueRep.add(++rearRep, tempPres);
repElems++;
break;
case "Whig":
queueWhig.add(++rearWhig, tempPres);
whigElems++;
break;
default:
//System.out.printf("\nNo party matching %s was found\n", partyQ);
} // end switch
} // end insert

/**
* Displays the Presidents elements in each array
*
* @param nothing
* @return Returns nothing
*/
public void displayQueues()
{
System.out.println("\n\n---------------------------------------------");
System.out.printf("\n\n%6s\n","Presidental Queues");
System.out.println("\n\nQueue 1 : Democrats");
System.out.printf("\n%-14s%-16s%s\n\n","Number", "Name", "Party");
displayDem();
System.out.println("\n\nQueue 2 : Republicans");
System.out.printf("\n%-14s%-16s%s\n\n","Number", "Name", "Party");
displayRep();
System.out.println("\n\nQueue 3 : Whigs");
System.out.printf("\n%-14s%-16s%s\n\n","Number", "Name", "Party");
displayWhig();
} // end displayQueues()
/**
* Displays each sorted queue's elements along with headers
*
* @param none
* @return Returns nothing
*/
public void displaySortedQueues()

{
System.out.println("\n\n---------------------------------------------");
System.out.printf("\n\n%6s\n","Sorted Presidental Queues");
System.out.println("\n\nQueue 1 : Democrats");
System.out.printf("\n%-14s%-16s%s\n\n","Number", "Name", "Party");
displayDem();
System.out.println("\n\nQueue 2 : Republicans");
System.out.printf("\n%-14s%-16s%s\n\n","Number", "Name", "Party");
displayRep();
System.out.println("\n\nQueue 3 : Whigs");
System.out.printf("\n%-14s%-16s%s\n\n","Number", "Name", "Party");
displayWhig();
} // end displayQueues()

/**
* Loop through and print each item in queueRep
*
* @param none
* @return Returns nothing
*/
private void displayRep()
{
for (int i = 0; i < repElems-1; i++)
{
System.out.println(queueRep.get(i));
} // end for
} // end displayRep()

/**
* Loop through and print each item in queueRep
*
* @param none
* @return Returns nothing
*/
private void displayDem()
{
for (int i = 0; i < demElems-1; i++)
{
System.out.println(queueDem.get(i));
} // end for
} // end displayDem()

/**
* Loop through and print each item in queueRep
*
* @param none
* @return Returns nothing
*/
private void displayWhig()
{
for (int i = 0; i < whigElems-1; i++)
{
System.out.println(queueWhig.get(i));
} // end for
} // end displayWhig()

/**
* Performs a selection sort of each of the the 3 queues
*
* @param None
* @return Returns nothing
*/
public void selectionSortAll()
{
selectionSortDem();
selectionSortRep();
selectionSortWhig();
}

/**
* Performs a selection sort of elements in queueDem
*
* @param None
* @return Returns nothing
*/
private void selectionSortDem()
{
int demIn, demOut, demMin;
for (demOut = 0; demOut < queueDem.size()-1; demOut++)
{
demMin = demOut;
for (demIn = demOut+1; demIn < queueDem.size(); demIn++)//inner loop
forward
{
if (queueDem.get(demMin).getNumber() >
queueDem.get(demIn).getNumber())//if out of order

if (queueDem.get(demMin).getNumber() >
queueDem.get(demIn).getNumber())//if out of order
demMin = demIn;
} // end for loop
demSwap(demOut, demMin);
} // end for loop
} // end .....

/**
* Performs a selection sort of elements in queueRep
*
* @param None
* @return Returns nothing
*/
private void selectionSortRep()
{
int repNumIn, repNumOut, repMin;
for (repNumOut = 0; repNumOut < queueRep.size()-1; repNumOut++)
{
repMin = repNumOut;
for (repNumIn = repNumOut+1; repNumIn < queueRep.size();
repNumIn++)//inner loop forward
{
if (queueRep.get(repMin).getNumber() >
queueRep.get(repNumIn).getNumber())//if out of order
repMin = repNumIn;
} // end for loop
repSwap(repNumOut, repMin);
} // end for loop
} // end .....

/**
* Performs a selection sort of elements in queueWhig
*
* @param None
* @return Returns nothing
*/
private void selectionSortWhig()
{
int whigNumIn, whigNumOut, whigMin;
for (whigNumOut = 0; whigNumOut < queueWhig.size()-1; whigNumOut++)
{
whigMin = whigNumOut;

for (whigNumIn = whigNumOut+1; whigNumIn < queueWhig.size();

whigNumIn++)//inner loop forward
{
if (queueWhig.get(whigMin).getNumber() >
queueWhig.get(whigNumIn).getNumber())//if out of order
whigMin = whigNumIn;
} // end for loop
whigSwap(whigNumOut, whigMin);
} // end for loop
} // end .....

/**
* Swaps the positions of the 2 objects in queueDem
*
* @param one : integer
* @param two : integer
* @return returns nothing
*/
private void demSwap(int one, int two)
{
Presidents temp = queueDem.get(one);
queueDem.set(one, queueDem.get(two));
queueDem.set(two, temp);
} // end swap method

/**
* Swaps the positions of the 2 objects in queueRep
*
* @param one : integer
* @param two : integer
* @return returns nothing
*/
private void repSwap(int one, int two)
{
Presidents temp = queueRep.get(one);
queueRep.set(one, queueRep.get(two));
queueRep.set(two, temp);
} // end swap method

/**
* Swaps the positions of the 2 objects in queueWhig
*
* @param one : integer
* @param two : integer
* @return returns nothing

*/
private void whigSwap(int one, int two)
{
Presidents temp = queueWhig.get(one);
queueWhig.set(one, queueWhig.get(two));
queueWhig.set(two, temp);
} // end swap method

/**
* Inserts Presidents item in queue based on party, item is arranged within by
number
*
* @param item : Presidents
* @return Returns nothing
*/
public void priorityInsert(Presidents item)
// insert item
{
int j;
switch (item.getParty()) // sorts by party
{
case "Democrat":
if(demElems == 0)
// if no items,
queueDem.add(demElems++, item); // insert at 0
else
// if items,
{
for(j=demElems-1; j >= 0; j--)
// start at end,
{
if(item.getNumber() <= queueDem.get(j).getNumber()) // if new
item larger,
{
queueDem.add(j+1, queueDem.get(j)); // shift upward
queueDem.remove(j);
} // end if
else // if smaller,
break; // done shifting
} // end for
queueDem.add(j+1, item);
demElems++;
} // end else
break;

// insert it

case "Republican":
if(repElems == 0)

// if no items,

queueRep.add(repElems++, item);

// insert at 0

else
// if items,
{
for(j=repElems-1; j >= 0; j--)
// start at end,
{
if(item.getNumber() <= queueRep.get(j).getNumber()) // if new
item larger,
{
queueRep.add(j+1, queueRep.get(j)); // shift upward
queueRep.remove(j);
} // end if
else // if smaller,
break; // done shifting
} // end for
queueRep.add(j+1, item);
repElems++;
} // end else
break;

// insert it

case "Whig":
if(whigElems == 0)
queueWhig.add(whigElems++, item);

// if no items,
// insert at 0

else
// if items,
{
for(j=whigElems-1; j >= 0; j--)
// start at end,
{
if(item.getNumber() <= queueWhig.get(j).getNumber()) // if new
item larger,
{
queueWhig.add(j+1, queueWhig.get(j)); // shift upward
queueWhig.remove(j);
} // end if
else // if smaller,
break; // done shifting
} // end for
queueWhig.add(j+1, item);
whigElems++;
} // end else
break;
default:
break;
} // end switch
} // end priorityInsert()

// insert it

/**
* Displays each queue, all below an "Updated Priority Queue" heading
*
* @param none
* @return Returns nothing
*/
public void displayPriorityQueue()
{
System.out.println("\n\n---------------------------------------------");
System.out.println("\n\nUpdated Priority Queues:");
System.out.println("\n\nQueue 1 : Democrats");
System.out.printf("\n%-14s%-16s%s\n\n","Number", "Name", "Party");
displayDem();
System.out.println("\n\nQueue 2 : Republicans");
System.out.printf("\n%-14s%-16s%s\n\n","Number", "Name", "Party");
displayRep();
System.out.println("\n\nQueue 3 : Whigs");
System.out.printf("\n%-14s%-16s%s\n\n","Number", "Name", "Party");
displayWhig();
} // end displayPriorityQueue()
} // end class Queue

package project2Final;
/**
* Performs stack functions on an array of Presidents objects
*
* @author Matthew Ramsay
* @since 2016-09-24
*/
public class Stack
{
private int maxSize; // size of stack array
private Presidents[] stackArray;
private int top;

/**
* Stack constructor

*
* @param size : integer
* @return Returns nothing
*/
public Stack(int size)
{
maxSize = size; // set array size
stackArray = new Presidents[maxSize];
top = -1;
}

/**
* Pushes Presidents object on top of stack
*
* @param tempPres : Presidents
* @return Returns nothing
*/
public void push(Presidents tempPres)
{
stackArray[++top] = tempPres; // increment top, insert item
} // end push()

/**
* Removes Presidents object from top of stack
*
* @param none
* @return Returns Presidents element removed from stack
*/
public Presidents pop()
{
return stackArray[top--]; // access item, decrement top
} // end pop()

/**
* Checks if stack is empty
*
* @param none
* @return Returns true if stack is empty, otherwise false
*/
public boolean isEmpty() // true if stack is empty
{
return (top == -1);
} // end isEmpty()

/**
* Checks if stack is full
*
* @param none
* @return Returns true if stack is full, otherwise false
*/
public boolean isFull()
{
return (top == maxSize-1);
} // end isFull()

/**
* Displays all stack elements
*
* @param none
* @return Returns nothing
*/
public void displayStack()
{
System.out.printf("%-14s%-16s%s\n\n","Number", "Name", "Party");
System.out.println("Top of stack:");
for (int i = 0; i < maxSize; i++)
System.out.println(stackArray[i]);
System.out.println("Bottom of stack");
}
} // end class Stack

package project2Final;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/**
* Reads external files of Presidents objects and manipulates them using stacks
*
* @author Matthew Ramsay
* @since 2016-09-24
*/
public class FileIO
{
private FileReader fr1;
private BufferedReader br1;

private String inputString, name, party;

private int number;
private Stack presReadIn;

/**
* FileIO constructor
*
* @param file : String
* @param size : integer
* @return "Return value or Returns nothing"
*/
public FileIO(String file, int size) throws IOException
{
fr1 = new FileReader(file);
br1 = new BufferedReader (fr1);
presReadIn = new Stack(size); // aggregation; has a stack in the
constructor
} // end FileIO()

/**
* Reads file, creates Presidents objects, adds object to stack
*
* @param none
* @return Returns nothing
*/
public void readPresidents() throws IOException
{
inputString = br1.readLine();
Presidents temp;
while (inputString != null)
{
number = Integer.parseInt(inputString.substring(0,2).trim());
name = inputString.substring(2, 25).trim();
party = inputString.substring(29, 48).trim();
temp = new Presidents(number, name, party);
presReadIn.push(temp);
inputString = br1.readLine();
} //end while loop
} // end readPresidents()

/**
* Checks if stack is full

*
* @param none
* @return Returns true if stack is full, otherwise false
*/
public boolean presRemaining()
{
if(!presReadIn.isEmpty())
return true;
else
return false;
} // end presRemaining()

/**
* Removes President from top of stack
*
* @param none
* @return President at top of stack
*/
public Presidents getNextPresident()
{
return presReadIn.pop();
} // end getNextPresident()

/**
* Displays the stack of Presidents used to update initial group
*
* @param none
* @return Returns nothing
*/
public void showNewPres()
{
System.out.println("\n\n---------------------------------------------");
System.out.println("\n\nInput Stack for Updating Priority Queues\n");
presReadIn.displayStack();
} // end showNewPres()
} // end FileIO