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
    }
}
 

public class PriorityTreatmentUnit extends TreatmentUnit {
 
               protected double getPriority(Patient patient) {
                              return 0.0;
               }
 
               @Override
               protected boolean startTreatment(Doctor doctor) {
                              Patient patient = null;
                              for (Patient patient2 : getWaitingPatients()) {
                                            if (doctor.canTreat(patient2) > 0.0 && (patient == null || getPriority(patient2) > getPriority(patient))) {
                                                           patient = patient2;
                                            }
                              }
                              if (patient != null) {
                                            doctor.setPatient(patient);
                                            return true;
                              }
                              return false;
               }
}
 
/* PSEUDOKODE-eksempel FOR startTreatment(doctor)
* Går gjennom alle pasienter som venter (getWaitingPatients()) og
* holder rede på den med høyest prioritet (getPriority).
* Sjekker om det finnes en doktor
* med riktig kompetanse (canTreat)
* Hvis man har funnet en pasient som kan behandles,
* så får doktoren denne (setPatient) og true returneres.
*/
 
public class EmergencyPriorityTreatmentUnit extends PriorityTreatmentUnit {
 
               @Override
               public boolean startTreatment(Patient patient) {
                              if (! super.startTreatment(patient)) {
                                            Patient patientToSuspend = null;
                                            for (Doctor doctor : getAllDoctors()) {
                                                           if (doctor.canTreat(patient) > 0.0) {
                                                                          Patient existingPatient = doctor.getPatient();
                                                                          if (existingPatient != null && getPriority(existingPatient) < getPriority(patient) &&
                                                                                                        (patientToSuspend == null || getPriority(existingPatient) < getPriority(patientToSuspend))) {
                                                                                         patientToSuspend = existingPatient;
                                                                          }
                                                           }
                                            }
                                            if (patientToSuspend != null) {
                                                  getDoctor(patientToSuspend).setPatient(patient);
                                                           startTreatment(patientToSuspend);
                                                           return true;
                                            }
                              }
                              return false;
               }
}

// 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...
}

public interface TreatmentListener {
 
               public void treatmentStarted(Doctor doctor, Patient patient, TreatmentUnit treatmentUnit);
 
}
 
public class TreatmentUnit {
 
               // Lots of code unchanged here, find it in part 2 of TU.
 
 
               private Collection<TreatmentListener> treatmentListeners = new ArrayList<>();
 
               public void addTreatmentListener(TreatmentListener listener) {
                              treatmentListeners.add(listener);
               }
 
               public void removeTreatmentListener(TreatmentListener listener) {
                              treatmentListeners.remove(listener);
               }
 
               private void fireTreatmentStarted(Doctor doctor, Patient patient) {
                              for (TreatmentListener treatmentListener : treatmentListeners) {
                                             treatmentListener.treatmentStarted(doctor, patient, this);
                              }
               }
 
               private boolean startTreatment(Doctor doctor) {
                              for (Patient patient : getWaitingPatients()) {
                                            if (doctor.canTreat(patient) > 0.0) {
                                                           doctor.setPatient(patient);
                                                           fireTreatmentStarted(doctor, patient);
                                                           return true;
                                            }
                              }
                              return false;
               }
 
               private boolean startTreatment(Patient patient) {
                              for (Doctor doctor : getAvailableDoctors()) {
                                            if (doctor.canTreat(patient) > 0.0) {
                                                           doctor.setPatient(patient);
                                                           fireTreatmentStarted(doctor, patient);
                                                           return true;
                                            }
                              }
                              return false;
               return false;
               }
}}
}

public class TreatmentUnitController implements TreatmentListener {
 
               private TreatmentUnit treatmentUnit;
 
               public TreatmentUnitController() {
                              treatmentUnit = new TreatmentUnit();
                              
              // ...
 
                              treatmentUnit.addTreatmentListener(this);
               }
 
               @FXML
               private Label patientMessage;
 
               @Override
               public void treatmentStarted(Doctor doctor, Patient patient, TreatmentUnit treatmentUnit) {
                              patientMessage.setText(patient.getName() + " bes gå til doktor " + doctor.getName());
               }
}