Page History

/**
 * A patient has a set of conditions (of type String) that needs to be treated.
 */
public class Patient {

    
    /**
     * Indicates if this patient has conditions that needs to be treated.
     * @return true if this patient has conditions that needs to be treated, 
     * false otherwise.
     */
    public boolean requiresTreatment() { // 2a
        // Implementation hidden
    }

}

/**
 * A doctor has the capacity to treat one patient at a time.
 * The doctor as a list of competencies (of type String) that
 * indicates what conditions s/he can treat.
 */
public class Doctor {

    /**

     * Initialise this doctor with a set of competencies.
     * @param competencies
     */
    public Doctor(...) { // 2b
        // Implementation hidden
    }
    
    /**
     * Indicates to what extent this doctor can treat the provided patient.
     * The value is the number of the patient's conditions this doctor can
     * treat divided by the number of conditions the patient has.
     * Conditions and competences are matched using simple String comparison.
     * @param patient
     * @return the ratio of the patient's conditions that this doctor 
     * can treat.
     */
    public double canTreat(final Patient patient) { // 2b
        // Implementation hidden
    }

    /**
     * "Treats" the patient by removing all the patient's conditions 
     * that this doctor can treat.
     */
    public void treat() { // 2b
        // Implementation hidden
    }

    /**
     * @return the patient this doctor is treating, or null if s/he 
     * isn't currently treating any patient.
     */
    public Patient getPatient() {
        // Implementation hidden
    }

    /**
     * @return true if this doctor is currently treating a patient, 
     * otherwise false.
     */
    public boolean isAvailable() {
        // Implementation hidden
    }

    /**
     * Sets the patient that this doctor is treating, use null to 
     * indicate s/he isn't currently treating any patient.
     * @param patient
     */
    public void setPatient(final Patient patient) {
        // Implementation hidden
    }
}

/**
 * A class for managing a set of doctors and the patients they're treating.
 * When doctors or patients arrive, it is made sure that patients are treated 
 * as soon as possible.
 */
public class TreatmentUnit {

    // Internal declaration hidden
    
    /**
     * Adds a doctor and makes sure s/he starts treating a patient, if one 
     * is waiting.
     * @param doctor
     */
    public void addDoctor(final Doctor doctor) {
        // Possible changes
    }

    /**
     * @return the currently available doctors
     */
    public Collection<Doctor> getAvailableDoctors() {
        // Possible changes
    }

    /**
     * Adds a patient to this treatment unit, and makes sure treatment starts
     * if any doctor is available.
     * Otherwise the patient is queued for treatment when a doctor becomes
     * available.
     * @param patient
     */
    public void addPatient(final Patient patient) {
        // Possible changes
    }

    /**
     * @param pred the predicate that the doctor must satisfy
     * @return some doctor satisfying the predicate
     */
    public Doctor getDoctor(final Predicate<Doctor> pred) {
        // Possible changes
    }

    /**
     * Find the doctor, if any, that treats the provided patient.
     * @param patient
     * @return the doctor treating the provided patient, or null if the 
     * patient isn't currently being treated.
     */
    public Doctor getDoctor(final Patient patient) {
        // Possible changes
    }

    /**
     * Find all patients that are not currently being treated
     * @return the patients not currently being treated
     */
    public Collection<Patient> getWaitingPatients() {
        // Possible changes
    }

    /**
     * Finds a waiting patient and sets him/her as the provided doctor's patient.
     * Will only accept a patient that has some condition that the doctor actually 
     * can treat.
     * @param doctor the doctor for which a patient to treat should be found
     * @return true if a patient for the provided doctor was found, false 
     * otherwise.
     */
    private boolean startTreatment(final Doctor doctor) {
        // Implementation hidden
    }

    /**
     * Finds an available doctor for the provided patient, and sets that doctor to 
     * treat the patient.
     * Will only accept a doctor that actually can treat some condition for the 
     * provided patient.
     * @param patient the patient for which a treating doctor should be found
     * @return true if a doctor for the provided patient was found, false 
     * otherwise.
     */
    private boolean startTreatment(final Patient patient) {
        // Implementation hidden
    }

    /**
     * Removes the link between doctor and patient, after treatment is finished.
     * If the patient is fully treated, s/he is removed from this treatment unit,
     * otherwise another round of treatment is initiated.
     * Also ensure the doctor starts treating another patient.
     * @param doctor the doctor that has finished treating his/her patient
     */
    public void treatmentFinished(final Doctor doctor) {
        // Implementation hidden
    }
}

 // TreatmentUnit.fxml:

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.scene.layout.VBox?>

<?import javafx.scene.control.Label?>

<?import javafx.scene.layout.HBox?>

<?import javafx.scene.text.Font?>

<HBox xmlns:fx="http://javafx.com/fxml/1" fx:controller="ord2019.part5.TreatmentUnitController">

            <Label fx:id="patientMessage" text="&lt;Her kommer meldinger til pasienter&gt;">

            </Label>

</HBox>

// TreatmentUnitController.java:

public class TreatmentUnitController {

            TreatmentUnit treatmentUnit;

            public TreatmentUnitController() {

                        treatmentUnit = // assume treatmentUnit is set automatically.

                        ... 5 b) other initialization ...

            }

            ... 5 b) declarations and methods here...

}