Question & Answer: 1 Project 4 Introduction – the SeaPort Project series For this set of projects for the course, we wish to simulate some of the…..

The following is the required program as per your requirements. Code to copy is given at the end. Get back to me if you have any doubts.

Program Screenshot:

Thing.java

Dock.java

Job.java

World.java

Person.java

SeaPort.java

Ship.java

CargoShip.java

PassengerShip.java

PortTime.java

SeaPortProgram.java

Input text file: aSPaa.txt

Screenshot of the output:

Uml class diagram:

Code to copy:

Thing.java

import java.util.HashMap;

import java.util.Scanner;

//define the class Thing implements Comparable

public class Thing implements Comparable<Thing> {

//declare the variables

private String name;

private int index;

private int parent;

Thing thinkObject;

//constructor

public Thing(){}

//constructor

public Thing(Scanner sc) {

this.name = sc.next();

this.index = sc.nextInt();

this.parent = sc.nextInt();

}

//getter methods

public int getIndex() {

return index;

}

public String getName() {

return name;

}

public int getParent() {

return parent;

}

//setter method

public void setThingObject(HashMap parentHashMap){

if(parentHashMap.get(parent) != null)

thinkObject = (Thing) parentHashMap.get(parent);

}

//definition of the compareTo() method

@Override

public int compareTo(Thing obj) {

return name.compareTo(obj.getName());

}

//definition of the toString() method

synchronized public String toString() {

return name + ” ” + index;

}

}

Dock.java

import java.util.ArrayList;

import java.util.Scanner;

//define the class Dock extends Thing

public class Dock extends Thing

{

// declare the variables

private Ship ship;

// constructor

public Dock(Scanner sc)

{

super(sc);

}

// definition of the method setShip

public void setShip(Ship ship)

{

synchronized (this)

{

this.ship = ship;

if (ship != null)

{

this.ship.thinkObject = this;

}

}

}

// definition of the method getShip

public Ship getShip()

{

return ship;

}

// definition of the method leaveShipFromDock()

public void leaveShipFromDock()

{

setShip(null);

checkDocksAtDock();

}

// definition of the method requestForNewShip()

private void requestForNewShip()

{

Ship ship = ((SeaPort) thinkObject).getShipFromQue();

if (ship != null)

setShip(ship);

}

// definition of the method checkDocksAtDock()

public void checkDocksAtDock()

{

if (ship == null || ship.ships.size() == 0)

requestForNewShip();

}

// definition of the method requestPersonnel()

boolean requestPersonnel(ArrayList<String> requirements)

{

return ((SeaPort) thinkObject).requestPersonnel(requirements);

}

// definition of the method requestWorkers()

public ArrayList<Person> requestWorkers(ArrayList<String> requirements,

Job job)

{

return ((SeaPort) thinkObject).requestWorkers(requirements, job);

}

// definition of the method releaseWorkers()

public void releaseWorkers(ArrayList<Person> workers)

{

((SeaPort) thinkObject).releaseWorkers(workers);

}

// definition of the method toString()

public String toString()

{

if (ship != null)

return “n Dock: ” + super.toString() + “n ” + ship.toString();

else

return “n Dock: ” + super.toString();

}

}

Job.java

import javax.swing.*;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Scanner;

//define the class Job extends Thing implements Runnable

public class Job extends Thing implements Runnable {

//declare the variables

private ArrayList<String> requirements = new ArrayList<String>();

JPanel panel;

long duration;

JProgressBar bar = new JProgressBar();

boolean flag = true, noKillFlag = true;

JButton stop = new JButton(“Stop”);

JButton cancel = new JButton(“Cancel”);

Status status = Status.WAITING;

Job removedJob;

Ship parentShip;

enum Status {RUNNING, SUSPENDED, WAITING, DONE}

//constructor

public Job(Scanner sc) {

super(sc);

duration = (long) sc.nextDouble();

while (sc.hasNext()) {

String requirement = sc.next();

if (requirement != null && requirement.length() > 0)

requirements.add(requirement);

}

}

//definition of the method setThingObject()

public void setThingObject(HashMap thinkObject) {

if (thinkObject.get(getParent()) != null) {

this.thinkObject = (Thing) thinkObject.get(getParent());

parentShip = (Ship) this.thinkObject;

setElements();

removedJob = this;

new Thread(this).start();

}

}

//definition of the method setElements()

private void setElements() {

panel = new JPanel();

bar = new JProgressBar();

bar.setStringPainted(true);

stop.setMinimumSize(new Dimension(120, 25));

stop.setMaximumSize(new Dimension(120, 25));

GroupLayout groupLayout = new GroupLayout(panel);

panel.setLayout(groupLayout);

setLayout(groupLayout);

setActionListeners();

}

//definition of the method setLayout()

private void setLayout(GroupLayout groupLayout) {

groupLayout.setAutoCreateGaps(true);

groupLayout.setAutoCreateContainerGaps(true);

JLabel jLabel = new JLabel(parentShip.getName(),

SwingConstants.CENTER);

jLabel.setMinimumSize(new Dimension(150, 25));

jLabel.setMaximumSize(new Dimension(150, 25));

groupLayout.setHorizontalGroup(groupLayout.createSequentialGroup()

.addComponent(bar)

.addComponent(jLabel)

.addComponent(stop)

.addComponent(cancel));

groupLayout.setVerticalGroup(groupLayout.createParallelGroup

(GroupLayout.Alignment.LEADING)

.addComponent(bar)

.addComponent(jLabel)

.addComponent(stop)

.addComponent(cancel));

}

//definition of the method getPanel()

public JPanel getPanel() {

return panel;

}

//definition of the method setActionListeners()

private void setActionListeners() {

stop.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

setFlag();

}

});

cancel.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

setKillFlag();

}

});

}

//definition of the method setFlag()

public void setFlag() {

flag = !flag;

}

//definition of the method setKillFlag()

public void setKillFlag() {

noKillFlag = false;

cancel.setBackground(Color.red);

}

//definition of the method showStatus()

void showStatus(Status st) {

status = st;

switch (status) {

case RUNNING:

stop.setBackground(Color.green);

stop.setText(“Running”);

break;

case SUSPENDED:

stop.setBackground(Color.yellow);

stop.setText(“Suspended”);

break;

case WAITING:

stop.setBackground(Color.orange);

stop.setText(“Waiting turn”);

break;

case DONE:

stop.setBackground(Color.red);

stop.setText(“Done”);

break;

}

}

//definition of the method run()

public void run() {

// wait for the world to be initialized, otherwise

//simulation does not work properly

while (!World.getValue())

waitTime(300);

while (!parentShip.isShipDocked()) {

waitTime(100);

}

while (!parentShip.processShip()) {

waitTime(100);

}

ArrayList<Person> workers = null;

if (requirements.size() == 0 || parentShip.

requestPersonnel(requirements)) {

if (requirements.size() != 0) {

do {

waitTime(100);

workers = parentShip.requestWorkers(requirements,

removedJob);

} while (workers == null || workers.size() !=

requirements.size());

}

long time = System.currentTimeMillis();

long startTime = time;

long stopTime = time + 1000 * duration;

double duration = stopTime – time;

while (time < stopTime && noKillFlag) {

waitTime(100);

if (flag) {

showStatus(Status.RUNNING);

time += 100;

bar.setValue((int) (((time – startTime) /

duration) * 100));

} else {

showStatus(Status.SUSPENDED);

}

}

bar.setValue(100);

showStatus(Status.DONE);

} else {

showStatus(Status.SUSPENDED);

}

if (workers != null && workers.size() > 0)

parentShip.releaseWorkers(workers);

parentShip.removeShip(removedJob);

}

//definition of the method waitTime()

private void waitTime(long l) {

try {

Thread.sleep(l);

} catch (InterruptedException e) {

}

}

//definition of the method toString()

public String toString() {

return String.format(“j:%7d:%15s:%5d”, getIndex(),

getName(), duration);

}

}

World.java

import java.util.*;

//define the class World that extends the class Thing

public class World extends Thing {

//declare the variables

HashMap<Integer, SeaPort> ports;

PortTime time;

static boolean value = false;

//define the conresultuctor

public World() {

ports = new HashMap<Integer, SeaPort>();

}

//getter and setter methods

public static void setValue(){

value = true;

}

public static boolean getValue(){

return value;

}

//definition of the method readFile()

// takes Scanner object and reads the data from the file

public void readFile(Scanner scan) {

// Create an object for Hashmap for Dock class

HashMap<Integer, Dock> dockHashMap = new HashMap<Integer, Dock>();

// Create an object for Hashmap for Ship class

HashMap<Integer, Ship> shipHashMap = new HashMap<Integer, Ship>();

// read the data using while loop

while (scan.hasNextLine()) {

//read the line

String line = scan.nextLine();

//replace with space comma

line = line.replaceAll(“^\s+”, “”);

if (line.length() > 0 && line.charAt(0) != ‘/’)

{

Scanner sc = new Scanner(line);

if (!sc.hasNext())

return;

String word = sc.next().toLowerCase();

//if the word is port then call the method addPort()

if (word.matches(“port”))

addPort(sc);

//if the word is dock then call the method addDock()

else if (word.matches(“dock”))

addDock(sc, dockHashMap);

//if the word is pship then call the method addPassengerShip()

else if (word.matches(“pship”))

addPassengerShip(sc, dockHashMap, shipHashMap);

//if the word is cship then call the method addCargoShip()

else if (word.matches(“cship”))

addCargoShip(sc, dockHashMap, shipHashMap);

//if the word is person then call the method addPerson()

else if (word.matches(“person”))

addPerson(sc);

//if the word is job then call the method addJob()

else if (word.matches(“job”))

addJob(sc, shipHashMap);

}

}

}

//definition of the method addJob()

private void addJob(Scanner sc, HashMap<Integer, Ship> shipHashMap) {

Job job = new Job(sc);

if (shipHashMap.get(job.getParent()) != null)

{

job.setThingObject(shipHashMap);

shipHashMap.get(job.getParent()).ships.add(job);

}

}

//definition of the method addPerson()

private void addPerson(Scanner sc) {

Person person = new Person(sc);

ports.get(person.getParent()).addPerson(person);

}

//definition of the method addCargoShip()

private void addCargoShip(Scanner sc, HashMap<Integer, Dock> dockHashMap,

HashMap<Integer, Ship> shipHashMap) {

CargoShip cargoShip = new CargoShip(sc);

shipHashMap.put(cargoShip.getIndex(), cargoShip);

assignShip(cargoShip, dockHashMap);

}

//definition of the method addPassengerShip()

private void addPassengerShip(Scanner sc, HashMap<Integer, Dock>

dockHashMap, HashMap<Integer, Ship> shipHashMap) {

PassengerShip passengerShip = new PassengerShip(sc);

shipHashMap.put(passengerShip.getIndex(), passengerShip);

assignShip(passengerShip, dockHashMap);

}

//definition of the method addDock()

private void addDock(Scanner sc, HashMap<Integer, Dock> dockHashMap)

{

Dock dock = new Dock(sc);

dock.setThingObject(ports);

dockHashMap.put(dock.getIndex(), dock);

// Add dock to port

ports.get(dock.getParent()).addDock(dock);

}

//definition of the method addPort()

private void addPort(Scanner scan) {

SeaPort seaPort = new SeaPort(scan);

ports.put(seaPort.getIndex(), seaPort);

}

//definition of the method assignShip()

private void assignShip(Ship ship, HashMap<Integer, Dock> dockHashMap) {

Dock dock = dockHashMap.get(ship.getParent());

if (dock == null) {

ship.setThingObject(ports);

ports.get(ship.getParent()).addShip(ship);

ports.get(ship.getParent()).addShipToQue(ship);

return;

}

if (dock.getShip() != null)

ports.get(ship.getParent()).addShipToQue(ship);

else

dock.setShip(ship);

ports.get(dock.getParent()).addShip(ship);

}

//definition of the method sortByShipName()

public String sortByShipName() {

List<SeaPort> list = new ArrayList<SeaPort>();

String result = “”;

for (SeaPort seaPort : ports.values()) {

seaPort.sortAllListsByName();

list.add(seaPort);

}

Collections.sort(list);

for (SeaPort seaPort : list) {

result += “Port: “;

result += seaPort.getName() + “n Ships:n “;

for (Ship ship : seaPort.ships) {

result += ship.getName() + “n “;

result += ” Jobs:n “;

for (Job job : ship.ships) {

result += job.getName() + “n “;

}

result += “n “;

}

result += “n Docks:n “;

for (Dock dock : seaPort.docks) {

result += dock.getName() + “n “;

}

result += “n People:n “;

for (Person person : seaPort.persons) {

result += person.getName() + “n “;

}

}

return result;

}

//definition of the method sortByShipWeight()

public String sortByShipWeight() {

String result = “”;

for (SeaPort seaPort : ports.values()) {

seaPort.sortByWeight();

result += “Port: “;

result += seaPort.getName() + “n Ships:n “;

for (Ship ship : seaPort.waitingShipsInQue) {

result += ship.getName() + “: ” + ship.weight + “n “;

}

result += “n”;

}

return result;

}

//definition of the method readFile()

public String sortByShipLength() {

String result = “”;

for (SeaPort seaPort : ports.values()) {

seaPort.sortByLength();

result += “Port: “;

result += seaPort.getName() + “n Ships:n “;

for (Ship ship : seaPort.waitingShipsInQue) {

result += ship.getName() + “: ” + ship.length + “n “;

}

result += “n”;

}

return result;

}

//definition of the method readFile()

public String sortByWidth() {

String result = “”;

for (SeaPort seaPort : ports.values()) {

seaPort.sortByWidth();

result += “Port: “;

result += seaPort.getName() + “n Ships:n “;

for (Ship ship : seaPort.waitingShipsInQue) {

result += ship.getName() + “: ” + ship.width + “n “;

}

result += “n”;

}

return result;

}

//definition of the method sortByShipDraft()

public String sortByShipDraft() {

String result = “”;

for (SeaPort seaPort : ports.values()) {

seaPort.sortByDraft();

result += “Port: “;

result += seaPort.getName() + “n Ships:n “;

for (Ship ship : seaPort.waitingShipsInQue) {

result += ship.getName() + “: ” + ship.draft + “n “;

}

result += “n”;

}

return result;

}

//definition of the method getDockByIndex()

private Dock getDockByIndex(int index) {

for (SeaPort port : ports.values())

for (Dock dock : port.docks)

if (dock.getIndex() == index)

return dock;

return null;

}

//definition of the method getShipByIndex()

private Ship getShipByIndex(int index) {

for (SeaPort port : ports.values())

for (Ship ms : port.ships)

if (ms.getIndex() == index)

return ms;

return null;

}

//definition of the method getPersonByIndex()

private Person getPersonByIndex(int index) {

for (SeaPort port : ports.values()) {

for (Person person : port.persons) {

if (person.getIndex() == index)

return person;

}

}

return null;

}

//definition of the method searchIndex()

public String searchIndex(String search) {

int index;

try {

index = Integer.parseInt(search);

} catch (NumberFormatException e) {

return “That is not a number!”;

}

String result = “”;

result += (getDockByIndex(index) != null) ?

getDockByIndex(index).toString() : “”;

result += (getShipByIndex(index) != null) ?

getShipByIndex(index).toString() : “”;

result += (getPersonByIndex(index) != null) ?

getPersonByIndex(index).toString() : “”;

result += (ports.get(index) != null) ?

ports.get(index).toString() : “”;

return result;

}

//definition of the method searchName()

public String searchName(String search) {

String result = “”;

for (SeaPort port : ports.values()) {

for (Dock dock : port.docks) {

if (dock.getName().toLowerCase().matches(search.

toLowerCase()))

result += dock.toString();

}

for (Ship ship : port.ships) {

if (ship.getName().toLowerCase().matches

(search.toLowerCase()))

result += ship.toString();

}

for (Person person : port.persons) {

if (person.getName().toLowerCase().matches

(search.toLowerCase()))

result += person.toString();

}

if (port.getName().toLowerCase().matches

(search.toLowerCase()))

result += port.toString();

}

return result;

}

//definition of the method readFile()

public String searchSkill(String search) {

String result = “”;

for (SeaPort port : ports.values()) {

for (Person person : port.persons) {

if (person.getSkill().toLowerCase().matches

(search.toLowerCase()))

result += person.toString();

}

}

return result;

}

//definition of the method toString()

public String toString() {

String result = “The world: “;

for (SeaPort sp : ports.values())

result += sp.toString();

return result;

}

}

Person.java

import java.util.Scanner;

//define the class Person extends Thing

public class Person extends Thing {

//declare the variables

private String skill;

boolean available = true;

//constructor

public Person(Scanner sc) {

super(sc);

if (sc.hasNext())

skill = sc.next();

}

//getter method

public String getSkill() {

return skill;

}

//definition of the method hirePerson()

// returns Person object

synchronized public Person hirePerson() {

if (available) {

available = false;

return this;

}

return null;

}

//definition of the method release()

synchronized public void release() {

if (!available)

available = true;

}

//definition of the method hasRequiredSkill()

public boolean hasRequiredSkill(String requirement) {

return requirement.toLowerCase().matches(skill.toLowerCase());

}

//definition of the method toString()

public String toString() {

return ” Person: ” + super.toString() + ” ” + skill;

}

}

SeaPort.java

import javax.swing.*;

import java.awt.*;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.Scanner;

//define the class SeaPort extends Thing

public class SeaPort extends Thing {

//declare the variables

ArrayList<Dock> docks = new ArrayList<Dock>();

// the list of ships waiting to dock

ArrayList<Ship> waitingShipsInQue = new ArrayList<Ship>();

// a list of all the ships at this port

ArrayList<Ship> ships = new ArrayList<Ship>();

// persons with skills at this port

ArrayList<Person> persons = new ArrayList<Person>();

ArrayList<Job> rewaitingShipsInQuestList = new ArrayList<Job>();

JPanel panel = new JPanel();

JLabel resourceLabel = new JLabel(“”, SwingConstants.LEFT);

JLabel rewaitingShipsInQuestLabel = new JLabel(“”, SwingConstants.LEFT);

JProgressBar resourceProgress;

//constructor

public SeaPort(Scanner sc) {

super(sc);

}

//definition of the method addDock()

public void addDock(Dock dock) {

docks.add(dock);

}

//definition of the method addShip()

public void addShip(Ship ship) {

ships.add(ship);

}

//definition of the method addShipToQue()

public void addShipToQue(Ship ship) {

waitingShipsInQue.add(ship);

}

//definition of the method addPerson()

public void addPerson(Person person) {

persons.add(person);

}

//definition of the method sortByWeight()

public void sortByWeight() {

Collections.sort(waitingShipsInQue, new Comparator<Ship>() {

@Override

public int compare(Ship s1, Ship s2) {

return (s1.weight < s2.weight ? -1 : (s1.weight == s2.

weight ? 0 : 1));

}

});

}

//definition of the method sortByLength()

public void sortByLength() {

Collections.sort(waitingShipsInQue, new Comparator<Ship>() {

@Override

public int compare(Ship s1, Ship s2) {

return (s1.length < s2.length ? -1 : (s1.length == s2.

length ? 0 : 1));

}

});

}

//definition of the method sortByWidth()

public void sortByWidth() {

Collections.sort(waitingShipsInQue, new Comparator<Ship>() {

@Override

public int compare(Ship s1, Ship s2) {

return (s1.width < s2.width ? -1 : (s1.width == s2.

width ? 0 : 1));

}

});

}

//definition of the method sortByDraft()

public void sortByDraft() {

Collections.sort(waitingShipsInQue, new Comparator<Ship>(){

@Override

public int compare(Ship s1, Ship s2) {

return (s1.draft < s2.draft ? -1 : (s1.draft == s2.

draft ? 0 : 1));

}

});

}

//definition of the method sortAllListsByName()

public void sortAllListsByName() {

Collections.sort(ships);

Collections.sort(docks);

Collections.sort(persons);

Collections.sort(waitingShipsInQue);

for (Ship ship : ships) {

Collections.sort(ship.ships);

}

for (Ship ship : waitingShipsInQue) {

Collections.sort(ship.ships);

}

}

//definition of the method getShipFromQue()

public Ship getShipFromQue() {

synchronized (this) {

if (waitingShipsInQue.size() > 0) {

Ship ship = waitingShipsInQue.get(waitingShipsInQue.

size() – 1);

waitingShipsInQue.remove(ship);

return ship;

}

}

return null;

}

//definition of the method toString()

public String toString() {

String result = “nnSeaPort: ” + super.toString();

for (Dock md : docks)

result += “n” + md.toString();

result += “nn — List of all ships in waitingShipsInQue:”;

for (Ship ms : waitingShipsInQue)

result += “n > ” + ms.toString();

result += “nn — List of all ships:”;

for (Ship ms : ships)

result += “n > ” + ms.toString();

result += “nn — List of all persons:”;

for (Person mp : persons)

result += “n > ” + mp.toString();

return result;

}

//definition of the method checkDocksAtSeaPort()

public synchronized void checkDocksAtSeaPort() {

for (Dock dock : docks) {

dock.checkDocksAtDock();

}

}

//definition of the method requestPersonnel()

public boolean requestPersonnel(ArrayList<String> requirements) {

ArrayList<Person> check = new ArrayList<Person>();

for (String requirement : requirements) {

for (Person person : persons) {

if (person.hasRequiredSkill(requirement) &&

!check.contains(person))

check.add(person);

if (check.size() == requirements.size()) return true;

}

}

return false;

}

//definition of the method requestWorkers()

public ArrayList<Person> requestWorkers(ArrayList<String>

requirements, Job job) {

ArrayList<Person> requiredWorkers = new ArrayList<Person>();

for (String requirement : requirements) {

for (Person person : persons) {

if (person.hasRequiredSkill(requirement))

synchronized (this) {

requiredWorkers.add(person.hirePerson());

}

if (requiredWorkers.size() == requirements.size()) {

broadcastUpdate();

if (rewaitingShipsInQuestList.contains(job))

rewaitingShipsInQuestList.remove(job);

return requiredWorkers;

}

}

}

if (!rewaitingShipsInQuestList.contains(job)) {

rewaitingShipsInQuestList.add(job);

}

if (requiredWorkers.size() > 0)

releaseWorkers(requiredWorkers);

return null;

}

//definition of the method requestWorkers()

public void releaseWorkers(ArrayList<Person> workers) {

for (Person worker : workers) {

if (worker != null)

synchronized (this) {

worker.release();

}

}

broadcastUpdate();

}

//definition of the method broadcastUpdate()

private void broadcastUpdate() {

int availableResources = getAvailableResources();

resourceLabel.setText(“Resources: ” + availableResources);

rewaitingShipsInQuestLabel.setText(“RewaitingShipsInQuests: ”

+ rewaitingShipsInQuestList.size());

if (resourceProgress != null) {

resourceProgress.setValue(availableResources);

if (availableResources < Math.round(persons.size() * 0.2)) {

resourceProgress.setForeground(Color.red);

} else if (availableResources < Math.round(persons.size() * 0.6)) {

resourceProgress.setForeground(Color.yellow);

} else {

resourceProgress.setForeground(Color.blue);

}

}

}

//definition of the method getAvailableResources()

private int getAvailableResources() {

int numOfAvailablePerson = 0;

for (Person person : persons) {

if (person.available)

numOfAvailablePerson++;

}

return numOfAvailablePerson;

}

//definition of the method setElements()

private void setElements() {

panel = new JPanel();

rewaitingShipsInQuestLabel.setMaximumSize(new Dimension(100, 20));

rewaitingShipsInQuestLabel.setMaximumSize(new Dimension(100, 20));

resourceLabel.setMinimumSize(new Dimension(100, 20));

resourceLabel.setMinimumSize(new Dimension(100, 20));

GroupLayout groupLayout = new GroupLayout(panel);

panel.setLayout(groupLayout);

setLayout(groupLayout);

}

//definition of the method setLayout()

private void setLayout(GroupLayout groupLayout) {

groupLayout.setAutoCreateGaps(true);

groupLayout.setAutoCreateContainerGaps(true);

JLabel portLabel = new JLabel(“Port: ” + getName(),

SwingConstants.LEFT);

portLabel.setMaximumSize(new Dimension(120, 20));

portLabel.setMinimumSize(new Dimension(120, 20));

resourceProgress = new JProgressBar(0, persons.size());

broadcastUpdate();

groupLayout.setHorizontalGroup(groupLayout.createSequentialGroup()

.addComponent(portLabel)

.addComponent(resourceProgress)

.addComponent(resourceLabel)

.addComponent(rewaitingShipsInQuestLabel)

);

groupLayout.setVerticalGroup(groupLayout.createParallelGroup

(GroupLayout.Alignment.LEADING)

.addComponent(portLabel)

.addComponent(resourceProgress)

.addComponent(resourceLabel)

.addComponent(rewaitingShipsInQuestLabel)

);

}

//definition of the method setLayout()

public Component getContainerPanel() {

setElements();

return panel;

}

}

Ship.java

import java.util.ArrayList;

import java.util.Scanner;

//define the class Ship that extends the class Thing

public class Ship extends Thing

{

// declare the variables.

private PortTime arrivalTime, dockTime;

double weight, length, width, draft;

ArrayList<Job> ships = new ArrayList<Job>();

private final Object lock = new Object();

private boolean shipInProcess;

// definition of the constructor

// that Scanner object and reads the values of

// weight, length, width and draft of the ship.

public Ship(Scanner key)

{

super(key);

if (key.hasNextDouble())

weight = key.nextDouble();

if (key.hasNextDouble())

length = key.nextDouble();

if (key.hasNextDouble())

width = key.nextDouble();

if (key.hasNextDouble())

draft = key.nextDouble();

dockTime = new PortTime();

}

// definition of the method isShipDocked()

// checks the Seaport and checks the Dock

// returns boolean value if the ship is docked or not.

public boolean isShipDocked()

{

if (thinkObject instanceof SeaPort)

((SeaPort) thinkObject).checkDocksAtSeaPort();

else

((Dock) thinkObject).checkDocksAtDock();

return thinkObject instanceof Dock

&& ((Dock) thinkObject).getShip() == this;

}

// definition of the method processShip()

// checks whether the ship is in process or not

// returns the boolean value.

public boolean processShip()

{

boolean process = false;

synchronized (lock)

{

if (!shipInProcess)

{

shipInProcess = true;

process = true;

}

}

return process;

}

// definition of the method removeShip()

// this method remove the ship from the dock by

// calling the method leaveShipFromDock()

public void removeShip(Job ship)

{

synchronized (lock)

{

shipInProcess = false;

}

if (ships.size() > 0 && ships.contains(ship))

ships.remove(ship);

if (ships.size() == 0)

{

((Dock) thinkObject).leaveShipFromDock();

}

}

// definition of the method requestPersonnel()

boolean requestPersonnel(ArrayList<String> requirements)

{

return ((Dock) thinkObject).requestPersonnel

(requirements);

}

// definition of the method requestPersonnel()

///returns the ArrayList of the Persons

public ArrayList<Person> requestWorkers(ArrayList<String>

requirements,

Job ship)

{

return ((Dock) thinkObject).requestWorkers(requirements,

ship);

}

// definition of the method releaseWorkers()

// takes arrayList of persons and calls the method

//releaseWorkers() from the Dock class

public void releaseWorkers(ArrayList<Person> workers)

{

((Dock) thinkObject).releaseWorkers(workers);

}

// definition of the method toString()

// returns a string of ship details.

public String toString()

{

String returns = (this instanceof PassengerShip ? “Passenger ”

: “Cargo “);

returns += “Ship: ” + super.toString();

if (ships.size() == 0)

return returns;

for (Job job : ships)

returns += “n – ” + job.toString();

return returns;

}

}

CargoShip.java

import java.util.Scanner;

//define the class CargoShip that extends Ship

public class CargoShip extends Ship {

//declare the variables

private double cargoValue;

private double cargoVolume;

private double cargoWeight;

//define the constructor

public CargoShip(Scanner sc) {

super(sc);

if (sc.hasNextDouble())

cargoValue = sc.nextDouble();

if (sc.hasNextDouble())

cargoVolume = sc.nextDouble();

if (sc.hasNextDouble())

cargoWeight = sc.nextDouble();

}

}

PassengerShip.java

import java.util.Scanner;

//define the class PassengerShip that extends Ship

public class PassengerShip extends Ship {

//declare the variables

private int numberOfOccupiedRooms;

private int numberOfPassengers;

private int numberOfRooms;

//define the constructor

public PassengerShip(Scanner sc) {

super(sc);

if (sc.hasNextInt())

numberOfPassengers = sc.nextInt();

if (sc.hasNextInt())

numberOfRooms = sc.nextInt();

if (sc.hasNextInt())

numberOfOccupiedRooms = sc.nextInt();

}

}

PortTime.java

//define the class PortTime

public class PortTime {

//declare the variables

int time;

//define the constructor

public PortTime() {

this.time = 0;

}

//setter method

public void setTime(int time){

this.time = time;

}

}

SeaPortProgram.java

import javax.swing.*;

import javax.swing.tree.DefaultMutableTreeNode;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.File;

import java.io.FileNotFoundException;

import java.util.Scanner;

//define the class SeaPortProgram

public class SeaPortProgram {

//declare the variables

static World world;

//definition of the main() method

public static void main(String[] args) {

Scanner scan;

world = new World();

try {

scan = new Scanner(new File(simulateFile()));

world.readFile(scan);

scan = null;

System.gc();

JDisplay jDisplay = new JDisplay(world.toString());

} catch (FileNotFoundException e) {

e.printStackTrace();

}

}

//definition of the simulateFile() method

private static String simulateFile() {

String file = null;

JFileChooser jFileChooser = new JFileChooser(“.”);

jFileChooser.setDialogTitle(“Please select a data file”);

jFileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);

if (jFileChooser.showOpenDialog(null) == JFileChooser.APPROVE_OPTION) {

file = jFileChooser.getSelectedFile().toString();

} else {

System.exit(0);

}

return file;

}

@SuppressWarnings(“serial”)

//definition of the class JDisplay extends JFrame

private static class JDisplay extends JFrame {

//declare the variables

String str;

JTextArea text;

JComboBox sortBox;

JComboBox combo;

JTextField textField;

JButton data;

JButton sortByNameButton;

JScrollPane scroll;

JTree jTree;

JScrollPane scrollPane;

public JDisplay(String str) {

this.str = str;

createAndShowGUI();

}

//definition of the addComponents() method

public void addComponents(Container contentPane) {

initComponentsAndSetFeatures();

addActionListeners();

setLayoutForDisplay(contentPane);

}

//definition of the addActionListeners() method

private void addActionListeners() {

sortBox.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

int index = sortBox.getSelectedIndex();

String sorted = sortShipsInQue(index);

if (index != 0 && !sorted.matches(str)) {

text.setText(sorted);

data.setEnabled(true);

}

}

});

combo.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

textField.setEditable(combo.getSelectedIndex() != 0);

}

});

textField.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

// Remove all redundant spaces

String searchStr = textField.getText().replaceAll(“[\s\t]+$”, “”).

replaceAll(“^[\s\t]+”, “”);

searchStr = searchStr.replaceAll(“(\s+){2,}”, “”);

String result = search(searchStr);

if (result != null && result.length() > 0) {

text.setText(result);

} else {

text.setText(“No result found!”);

}

data.setEnabled(result == null || !str.matches(result));

}

});

data.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

text.setText(str);

data.setEnabled(false);

}

});

sortByNameButton.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

text.setText(world.sortByShipName());

data.setEnabled(true);

}

});

}

//definition of the search() method

private String search(String stringSearch) {

switch (combo.getSelectedIndex()) {

case 1:

return world.searchIndex(stringSearch);

case 2:

return world.searchName(stringSearch);

case 3:

return world.searchSkill(stringSearch);

default:

return “”;

}

}

//definition of the sortShipsInQue() method

private String sortShipsInQue(int index) {

switch (index) {

case 1:

return world.sortByShipWeight();

case 2:

return world.sortByShipLength();

case 3:

return world.sortByWidth();

case 4:

return world.sortByShipDraft();

default:

return “”;

}

}

//definition of the setLayoutForDisplay() method

private void setLayoutForDisplay(Container contentPane) {

JSplitPane jSplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,

scroll, scrollPane);

JPanel containerForJobs = new JPanel();

JPanel containerForResources = new JPanel();

containerForJobs.setLayout(new BoxLayout(containerForJobs,

BoxLayout.Y_AXIS));

containerForResources.setLayout(new BoxLayout(containerForResources,

BoxLayout.Y_AXIS));

boolean hasJob = false;

boolean hasResource = false;

for (SeaPort seaPort : world.ports.values()) {

containerForResources.add(seaPort.getContainerPanel());

if (!hasResource)

hasResource = seaPort.persons.size() > 0;

for (Ship ship : seaPort.ships) {

for (Job job : ship.ships) {

containerForJobs.add(job.getPanel());

hasJob = true;

}

}

}

JScrollPane sPaneForJobsContainer = new JScrollPane(new JLabel

(“No jobs!”.toUpperCase(), SwingConstants.CENTER));

if (hasJob)

sPaneForJobsContainer = new JScrollPane(containerForJobs);

JScrollPane sPaneForResourcesContainer = new JScrollPane(new JLabel

(“No resources!”.toUpperCase(), SwingConstants.CENTER));

if (hasResource)

sPaneForResourcesContainer = new JScrollPane(containerForResources);

sPaneForJobsContainer.setMaximumSize(new Dimension(5660, 800));

sPaneForResourcesContainer.setMaximumSize(new Dimension(5660, 200));

GroupLayout layout = new GroupLayout(contentPane);

contentPane.setLayout(layout);

layout.setAutoCreateGaps(true);

layout.setAutoCreateContainerGaps(true);

layout.setHorizontalGroup(layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addComponent(combo)

.addComponent(textField))

.addComponent(sortBox)

.addComponent(jSplitPane)

.addGroup(layout.createSequentialGroup()

.addComponent(data)

.addComponent(sortByNameButton))

.addComponent(sPaneForResourcesContainer))

.addComponent(sPaneForJobsContainer));

layout.setVerticalGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(GroupLayout.Alignment.BASELINE)

.addComponent(combo)

.addComponent(textField))

.addComponent(sortBox)

.addComponent(jSplitPane)

.addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)

.addComponent(data)

.addComponent(sortByNameButton))

.addComponent(sPaneForResourcesContainer))

.addComponent(sPaneForJobsContainer));

}

//definition of the initComponentsAndSetFeatures() method

private void initComponentsAndSetFeatures() {

String[] sortOptions = {“Select a feature to sort ships in que”, “weight”,

“length”, “width”, “draft”};

String[] searchOptions = {“Select a feature to search”, “index”,

“name”, “skill”};

text = new JTextArea(str, 20, 60);

sortBox = new JComboBox(sortOptions);

combo = new JComboBox(searchOptions);

textField = new JTextField();

data = new JButton(“Reload Data”);

sortByNameButton = new JButton(“Sort All Things”);

textField.setPreferredSize(new Dimension(120, 25));

textField.setEditable(false);

sortBox.setSelectedIndex(0);

sortBox.setMaximumSize(new Dimension(5660, 25));

combo.setSelectedIndex(0);

text.setFont(new java.awt.Font(“Monospaced”, 0, 12));

text.setEditable(false);

text.setLineWrap(true);

scroll = new JScrollPane(text, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,

JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);

data.setEnabled(false);

initTree();

}

//definition of the initTree() method

private void initTree() {

DefaultMutableTreeNode top = new DefaultMutableTreeNode(“World”);

createNodes(top);

jTree = new JTree(top);

scrollPane = new JScrollPane(jTree);

}

//definition of the createNodes() method

private void createNodes(DefaultMutableTreeNode top) {

DefaultMutableTreeNode portNode;

for (SeaPort seaPort : world.ports.values()) {

portNode = createThingNode(seaPort);

DefaultMutableTreeNode node = new DefaultMutableTreeNode(“Docks”);

for (Dock dock : seaPort.docks) {

DefaultMutableTreeNode dockNode = createThingNode(dock);

if (dock.getShip() != null) {

DefaultMutableTreeNode shipNode = createThingNode(dock.getShip());

for (Job job : dock.getShip().ships) {

shipNode.add(createThingNode(job));

}

dockNode.add(shipNode);

}

node.add(dockNode);

portNode.add(node);

}

node = new DefaultMutableTreeNode(“Ships in Que”);

for (Ship ship : seaPort.waitingShipsInQue) {

DefaultMutableTreeNode shipNode = createThingNode(ship);

for (Job job : ship.ships) {

shipNode.add(createThingNode(job));

}

node.add(shipNode);

}

portNode.add(node);

node = new DefaultMutableTreeNode(“All Ships”);

for (Ship ship : seaPort.ships) {

DefaultMutableTreeNode shipNode = createThingNode(ship);

for (Job job : ship.ships) {

shipNode.add(createThingNode(job));

}

node.add(shipNode);

}

portNode.add(node);

node = new DefaultMutableTreeNode(“People”);

for (Person person : seaPort.persons) {

DefaultMutableTreeNode personNode = createThingNode(person);

node.add(personNode);

}

portNode.add(node);

top.add(portNode);

}

}

//definition of the createThingNode() method

private DefaultMutableTreeNode createThingNode(Thing thing) {

return new DefaultMutableTreeNode(thing.getIndex() + ” ” + thing.getName());

}

//definition of the createAndShowGUI() method

private void createAndShowGUI() {

JFrame frame = new JFrame(“Sea Port Simulation”);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//Set up the content pane and add swing components to it

addComponents(frame.getContentPane());

frame.setPreferredSize(new Dimension(1300, 800));

frame.pack();

frame.setVisible(true);

World.setValue(); // world is set!

}

}

}