Observer pattern

Author: fadeevab

Cargo.toml

@@ -21,4 +21,5 @@ members = [
   "behavioral/iterator",
   "behavioral/mediator",
   "behavioral/memento",
+  "behavioral/observer",
 ]

behavioral/observer/Cargo.toml

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

behavioral/observer/README.md

@@ -0,0 +1,17 @@
+# Observer
+
+In Rust, the convenient way to define a listener is to use a function as a callable object with complex logic.
+
+In this Observer example, Subscribers are either lambda functions or explicit functions subscribed to the event. Explicit function objects could be also unsubscribed (although, there could be limitations for some function types).
+
+```bash
+cargo run --bin observer
+```
+
+## Execution Result
+
+```
+Save log to /path/to/log/file.txt: Load file test1.txt
+Save log to /path/to/log/file.txt: Load file test2.txt
+Email to [email protected]: Save file test2.txt
+```

behavioral/observer/editor.rs

@@ -0,0 +1,22 @@
+use crate::observer::{Event, Publisher};
+
+#[derive(Default)]
+pub struct Editor {
+    publisher: Publisher,
+    file_path: String,
+}
+
+impl Editor {
+    pub fn events(&mut self) -> &mut Publisher {
+        &mut self.publisher
+    }
+
+    pub fn load(&mut self, path: String) {
+        self.file_path = path.clone();
+        self.publisher.notify(Event::Load, path);
+    }
+
+    pub fn save(&self) {
+        self.publisher.notify(Event::Save, self.file_path.clone());
+    }
+}

behavioral/observer/main.rs

@@ -0,0 +1,28 @@
+use editor::Editor;
+use observer::Event;
+
+mod editor;
+mod observer;
+
+fn main() {
+    let mut editor = Editor::default();
+
+    editor.events().subscribe(Event::Load, |file_path| {
+        let log = "/path/to/log/file.txt".to_string();
+        println!("Save log to {}: Load file {}", log, file_path);
+    });
+
+    editor.events().subscribe(Event::Save, save_listener);
+
+    editor.load("test1.txt".into());
+    editor.load("test2.txt".into());
+    editor.save();
+
+    editor.events().unsubscribe(Event::Save, save_listener);
+    editor.save();
+}
+
+fn save_listener(file_path: String) {
+    let email = "[email protected]".to_string();
+    println!("Email to {}: Save file {}", email, file_path);
+}

behavioral/observer/observer.rs

@@ -0,0 +1,38 @@
+use std::collections::HashMap;
+
+/// An event type.
+#[derive(PartialEq, Eq, Hash, Clone)]
+pub enum Event {
+    Load,
+    Save,
+}
+
+/// A subscriber (listener) has type of a callable function.
+pub type Subscriber = fn(file_path: String);
+
+/// Publisher sends events to subscribers (listeners).
+#[derive(Default)]
+pub struct Publisher {
+    events: HashMap<Event, Vec<Subscriber>>,
+}
+
+impl Publisher {
+    pub fn subscribe(&mut self, event_type: Event, listener: Subscriber) {
+        self.events.entry(event_type.clone()).or_default();
+        self.events.get_mut(&event_type).unwrap().push(listener);
+    }
+
+    pub fn unsubscribe(&mut self, event_type: Event, listener: Subscriber) {
+        self.events
+            .get_mut(&event_type)
+            .unwrap()
+            .retain(|&x| x != listener);
+    }
+
+    pub fn notify(&self, event_type: Event, file_path: String) {
+        let listeners = self.events.get(&event_type).unwrap();
+        for listener in listeners {
+            listener(file_path.clone());
+        }
+    }
+}