Mediator Pattern: Top-Down Ownership approach

Author: fadeevab

Cargo.toml

@@ -19,4 +19,5 @@ members = [
   "behavioral/chain-of-responsibility",
   "behavioral/command",
   "behavioral/iterator",
+  "behavioral/mediator",
 ]

behavioral/mediator/Cargo.toml

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

behavioral/mediator/README.md

@@ -0,0 +1,14 @@
+# Mediator Pattern
+
+There is a research and discussion of the Mediator pattern in Rust: https://github.com/fadeevab/mediator-pattern-rust.
+
+"Top-Down Ownership" approach allows to apply Mediator in Rust as it is a suitable for Rust's ownership model with strict borrow checker rules. It's not the only way to implement Mediator, but it's a fundamental one.
+
+## Top-Down Ownership
+
+The key point is thinking in terms of OWNERSHIP.
+
+1. A mediator takes ownership of all components.
+2. A component doesn't preserve a reference to a mediator. Instead, it gets the reference via a method call.
+3. Control flow starts from the `fn main()` where the mediator receives external events/commands.
+4. Mediator trait for the interaction between components is not the same as its external API for receiving external events (commands from the main loop).

behavioral/mediator/main.rs

@@ -0,0 +1,18 @@
+mod train_station;
+mod trains;
+
+use train_station::TrainStation;
+use trains::{FreightTrain, PassengerTrain};
+
+fn main() {
+    let train1 = PassengerTrain::new("Train 1");
+    let train2 = FreightTrain::new("Train 2");
+
+    let mut station = TrainStation::default();
+
+    station.accept(train1);
+    station.accept(train2);
+    station.depart("Train 1");
+    station.depart("Train 2");
+    station.depart("Train 3");
+}

behavioral/mediator/train_station.rs

@@ -0,0 +1,62 @@
+use std::collections::{HashMap, VecDeque};
+
+use crate::trains::Train;
+
+pub trait Mediator {
+    fn notify_about_arrival(&mut self, train_name: &str) -> bool;
+    fn notify_about_departure(&mut self, train_name: &str);
+}
+
+#[derive(Default)]
+pub struct TrainStation {
+    trains: HashMap<String, Box<dyn Train>>,
+    train_queue: VecDeque<String>,
+    train_on_platform: Option<String>,
+}
+
+impl Mediator for TrainStation {
+    fn notify_about_arrival(&mut self, train_name: &str) -> bool {
+        if self.train_on_platform.is_some() {
+            self.train_queue.push_back(train_name.into());
+            return false;
+        } else {
+            self.train_on_platform.replace(train_name.into());
+            return true;
+        }
+    }
+
+    fn notify_about_departure(&mut self, train_name: &str) {
+        if Some(train_name.into()) == self.train_on_platform {
+            self.train_on_platform = None;
+
+            if let Some(next_train_name) = self.train_queue.pop_front() {
+                let mut next_train = self.trains.remove(&next_train_name).unwrap();
+                next_train.arrive(self);
+                self.trains.insert(next_train_name.clone(), next_train);
+
+                self.train_on_platform = Some(next_train_name);
+            }
+        }
+    }
+}
+
+impl TrainStation {
+    pub fn accept(&mut self, mut train: impl Train + 'static) {
+        if self.trains.contains_key(train.name()) {
+            println!("{} has already arrived", train.name());
+            return;
+        }
+
+        train.arrive(self);
+        self.trains.insert(train.name().clone(), Box::new(train));
+    }
+
+    pub fn depart(&mut self, name: &'static str) {
+        let train = self.trains.remove(name.into());
+        if let Some(mut train) = train {
+            train.depart(self);
+        } else {
+            println!("'{}' is not on the station!", name);
+        }
+    }
+}

behavioral/mediator/trains/freight_train.rs

@@ -0,0 +1,32 @@
+use super::Train;
+use crate::train_station::Mediator;
+
+pub struct FreightTrain {
+    name: String,
+}
+
+impl FreightTrain {
+    pub fn new(name: &'static str) -> Self {
+        Self { name: name.into() }
+    }
+}
+
+impl Train for FreightTrain {
+    fn name(&self) -> &String {
+        &self.name
+    }
+
+    fn arrive(&mut self, mediator: &mut dyn Mediator) {
+        if !mediator.notify_about_arrival(&self.name) {
+            println!("Freight train {}: Arrival blocked, waiting", self.name);
+            return;
+        }
+
+        println!("Freight train {}: Arrived", self.name);
+    }
+
+    fn depart(&mut self, mediator: &mut dyn Mediator) {
+        println!("Freight train {}: Leaving", self.name);
+        mediator.notify_about_departure(&self.name);
+    }
+}

behavioral/mediator/trains/mod.rs

@@ -0,0 +1,13 @@
+mod freight_train;
+mod passenger_train;
+
+pub use freight_train::FreightTrain;
+pub use passenger_train::PassengerTrain;
+
+use crate::train_station::Mediator;
+
+pub trait Train {
+    fn name(&self) -> &String;
+    fn arrive(&mut self, mediator: &mut dyn Mediator);
+    fn depart(&mut self, mediator: &mut dyn Mediator);
+}

behavioral/mediator/trains/passenger_train.rs

@@ -0,0 +1,32 @@
+use super::Train;
+use crate::train_station::Mediator;
+
+pub struct PassengerTrain {
+    name: String,
+}
+
+impl PassengerTrain {
+    pub fn new(name: &'static str) -> Self {
+        Self { name: name.into() }
+    }
+}
+
+impl Train for PassengerTrain {
+    fn name(&self) -> &String {
+        &self.name
+    }
+
+    fn arrive(&mut self, mediator: &mut dyn Mediator) {
+        if !mediator.notify_about_arrival(&self.name) {
+            println!("Passenger train {}: Arrival blocked, waiting", self.name);
+            return;
+        }
+
+        println!("Passenger train {}: Arrived", self.name);
+    }
+
+    fn depart(&mut self, mediator: &mut dyn Mediator) {
+        println!("Passenger train {}: Leaving", self.name);
+        mediator.notify_about_departure(&self.name);
+    }
+}