Chain of Responsibility: Patient->Reception->etc.

Author: fadeevab

Cargo.toml

@@ -16,4 +16,5 @@ members = [
   "structural/facade",
   "structural/flyweight",
   "structural/proxy",
+  "behavioral/chain-of-responsibility",
 ]

behavioral/chain-of-responsibility/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+edition = "2021"
+name = "chain-of-responsibility"
+version = "0.1.0"
+
+[[bin]]
+name = "chain-of-responsibility"
+path = "main.rs"

behavioral/chain-of-responsibility/README.md

@@ -0,0 +1,31 @@
+# Chain of Responsibility
+
+## Conceptual Example
+
+The chain of responsibility is constructed as the following:
+
+```
+Patient -> Reception -> Doctor -> Medical -> Cashier
+```
+
+How to execute the example:
+
+```bash
+cargo run
+```
+
+## Execution Result
+
+```
+Reception registering a patient John
+Doctor checking a patient John
+Medical giving medicine to a patient John
+Cashier getting money from a patient John
+
+The patient has been already handled:
+
+Patient registration already done
+Doctor checkup has been already done
+Medicine has been already given to a patient
+Payment done
+```

behavioral/chain-of-responsibility/department.rs

@@ -0,0 +1,28 @@
+mod cashier;
+mod doctor;
+mod medical;
+mod reception;
+
+pub use cashier::Cashier;
+pub use doctor::Doctor;
+pub use medical::Medical;
+pub use reception::Reception;
+
+use crate::patient::Patient;
+
+pub trait Department {
+    fn execute(&mut self, patient: &mut Patient) {
+        self.handle(patient);
+
+        if let Some(next) = &mut self.next() {
+            next.execute(patient);
+        }
+    }
+
+    fn handle(&mut self, patient: &mut Patient);
+    fn next(&mut self) -> &mut Option<Box<dyn Department>>;
+}
+
+pub(self) fn into_next(department: impl Department + Sized + 'static) -> Option<Box<dyn Department>> {
+    Some(Box::new(department))
+}

behavioral/chain-of-responsibility/department/cashier.rs

@@ -0,0 +1,21 @@
+use super::{Department, Patient};
+
+#[derive(Default)]
+pub struct Cashier {
+    next: Option<Box<dyn Department>>,
+}
+
+impl Department for Cashier {
+    fn handle(&mut self, patient: &mut Patient) {
+        if patient.payment_done {
+            println!("Payment done");
+        } else {
+            println!("Cashier getting money from a patient {}", patient.name);
+            patient.payment_done = true;
+        }
+    }
+
+    fn next(&mut self) -> &mut Option<Box<dyn Department>> {
+        &mut self.next
+    }
+}

behavioral/chain-of-responsibility/department/doctor.rs

@@ -0,0 +1,26 @@
+use super::{Department, Patient, into_next};
+
+pub struct Doctor {
+    next: Option<Box<dyn Department>>,
+}
+
+impl Doctor {
+    pub fn new(next: impl Department + 'static) -> Self {
+        Self { next: into_next(next) }
+    }
+}
+
+impl Department for Doctor {
+    fn handle(&mut self, patient: &mut Patient) {
+        if patient.doctor_check_up_done {
+            println!("Doctor checkup has been already done");
+        } else {
+            println!("Doctor checking a patient {}", patient.name);
+            patient.doctor_check_up_done = true;
+        }
+    }
+
+    fn next(&mut self) -> &mut Option<Box<dyn Department>> {
+        &mut self.next
+    }
+}

behavioral/chain-of-responsibility/department/medical.rs

@@ -0,0 +1,26 @@
+use super::{Department, Patient, into_next};
+
+pub struct Medical {
+    next: Option<Box<dyn Department>>,
+}
+
+impl Medical {
+    pub fn new(next: impl Department + 'static) -> Self {
+        Self { next: into_next(next) }
+    }
+}
+
+impl Department for Medical {
+    fn handle(&mut self, patient: &mut Patient) {
+        if patient.medicine_done {
+            println!("Medicine has been already given to a patient");
+        } else {
+            println!("Medical giving medicine to a patient {}", patient.name);
+            patient.medicine_done = true;
+        }
+    }
+
+    fn next(&mut self) -> &mut Option<Box<dyn Department>> {
+        &mut self.next
+    }
+}

behavioral/chain-of-responsibility/department/reception.rs

@@ -0,0 +1,27 @@
+use super::{Department, Patient, into_next};
+
+#[derive(Default)]
+pub struct Reception {
+    next: Option<Box<dyn Department>>,
+}
+
+impl Reception {
+    pub fn new(next: impl Department + 'static) -> Self {
+        Self { next: into_next(next) }
+    }
+}
+
+impl Department for Reception {
+    fn handle(&mut self, patient: &mut Patient) {
+        if patient.registration_done {
+            println!("Patient registration already done");
+        } else {
+            println!("Reception registering a patient {}", patient.name);
+            patient.registration_done = true;
+        }
+    }
+
+    fn next(&mut self) -> &mut Option<Box<dyn Department>> {
+        &mut self.next
+    }
+}

behavioral/chain-of-responsibility/main.rs

@@ -0,0 +1,23 @@
+mod department;
+mod patient;
+
+use department::{Cashier, Department, Doctor, Medical, Reception};
+use patient::Patient;
+
+fn main() {
+    let cashier = Cashier::default();
+    let medical = Medical::new(cashier);
+    let doctor = Doctor::new(medical);
+    let mut reception = Reception::new(doctor);
+
+    let mut patient = Patient {
+        name: "John".into(),
+        ..Patient::default()
+    };
+
+    reception.execute(&mut patient);
+
+    println!("\nThe patient has been already handled:\n");
+
+    reception.execute(&mut patient);
+}

behavioral/chain-of-responsibility/patient.rs

@@ -0,0 +1,8 @@
+#[derive(Default)]
+pub struct Patient {
+    pub name: String,
+    pub registration_done: bool,
+    pub doctor_check_up_done: bool,
+    pub medicine_done: bool,
+    pub payment_done: bool,
+}