Merge pull request #4 from AndresCdo/mdabir1203-Main

Add design patterns and clean up code

Author: AndresCdo

.gitignore

@@ -3,16 +3,24 @@ target/
 
 # Ignore IDE-specific files
 .idea/
+
+# Ignore generated files
+Cargo.lock
+
+# Ignore editor-specific files
 *.iml
 
 # Ignore editor-specific files
 .vscode/
 
-# Ignore generated files
-Cargo.lock
+# Ignore test files
+*.rs
+
+# Ignore documentation files
+*.md
 
 # Ignore example files
 examples/
 
 # Ignore git-specific files
-.git/
+.git/

.idea/vcs.xml

@@ -0,0 +1,19 @@
+use std::cell::RefCell;
+
+fn main()
+{
+    let mut weather_station = WeatherStation::new();
+    let display1 = Rc::new(RefCell::new(DisplayDevice{
+        name: String::from("Display 1"),
+    }));
+    let display2 = Rc::new(RefCell::new(DisplayDevice{
+        name: String::from("Display 2"),
+    }));
+
+    weather_station.add_observer(display1);
+    weather_station.add_observer(display2);
+
+    weather_station.set_measurements(25.5, 60.0);
+    weather_station.set_measurements(26.0, 58.5);
+
+}

.idea/workspace.xml

@@ -0,0 +1,113 @@
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex, Once};
+use std::fs;
+use std::io;
+
+struct ConfigManager {
+    config: HashMap<String, String>,
+}
+
+impl ConfigManager {
+    fn new() -> Result<Self, io::Error> {
+        // Simulate loading configuration from a file
+        let config_str = fs::read_to_string("config.toml")?;
+        let config = parse_config(&config_str);
+        Ok(ConfigManager { config })
+    }
+
+    fn get(&self, key: &str) -> Option<&String> {
+        self.config.get(key)
+    }
+
+    fn set(&mut self, key: String, value: String) {
+        self.config.insert(key, value);
+    }
+
+    fn save(&self) -> Result<(), io::Error> {
+        // Simulate saving configuration to a file
+        let config_str = format_config(&self.config);
+        fs::write("config.toml", config_str)
+    }
+}
+
+fn get_config() -> Arc<Mutex<ConfigManager>> {
+    static mut SINGLETON: Option<Arc<Mutex<ConfigManager>>> = None;
+    static ONCE: Once = Once::new();
+
+    unsafe {
+        ONCE.call_once(|| {
+            match ConfigManager::new() {
+                Ok(config) => {
+                    SINGLETON = Some(Arc::new(Mutex::new(config)));
+                }
+                Err(e) => {
+                    eprintln!("Failed to initialize ConfigManager: {}", e);
+                    std::process::exit(1);
+                }
+            }
+        });
+
+        SINGLETON.clone().unwrap()
+    }
+}
+
+fn parse_config(config_str: &str) -> HashMap<String, String> {
+    // This is a simplified parser. In a real application, you'd use a proper TOML parser.
+    config_str
+        .lines()
+        .filter_map(|line| {
+            let parts: Vec<&str> = line.splitn(2, '=').collect();
+            if parts.len() == 2 {
+                Some((parts[0].trim().to_string(), parts[1].trim().to_string()))
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
+fn format_config(config: &HashMap<String, String>) -> String {
+    config
+        .iter()
+        .map(|(k, v)| format!("{} = {}", k, v))
+        .collect::<Vec<String>>()
+        .join("\n")
+}
+
+use std::thread;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Simulate multiple parts of an application accessing and modifying the configuration
+    let handles: Vec<_> = (0..3)
+        .map(|i| {
+            thread::spawn(move || {
+                let config = get_config();
+                let mut config = config.lock().unwrap();
+
+                // Read a configuration value
+                let db_url = config.get("database_url").cloned().unwrap_or_default();
+                println!("Thread {} read database_url: {}", i, db_url);
+
+                // Modify a configuration value
+                let new_value = format!("new_value_from_thread_{}", i);
+                config.set(format!("key_from_thread_{}", i), new_value.clone());
+                println!("Thread {} set new value: {}", i, new_value);
+
+                // Simulate some work
+                thread::sleep(std::time::Duration::from_millis(100));
+            })
+        })
+        .collect();
+
+    for handle in handles {
+        handle.join().unwrap();
+    }
+
+    // After all threads have finished, save the configuration
+    let config = get_config();
+    let config = config.lock().unwrap();
+    config.save()?;
+    println!("Configuration saved.");
+
+    Ok(())
+}

DesignModule04/Observer.rs

@@ -0,0 +1,6 @@
+[package]
+name = "StockMarket"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

DesignModule04/Singleton.rs

@@ -0,0 +1,84 @@
+# Stock Market Monitor (Observer Pattern)
+
+This project demonstrates the implementation of the Observer pattern in Rust using a Stock Market monitoring system as a real-world example.
+
+## Overview
+
+The Stock Market Monitor allows multiple observers (displays and alert systems) to receive updates whenever stock prices change. This showcases how the Observer pattern can be used to implement a publish-subscribe model.
+
+## Features
+
+- Real-time updates of stock prices to multiple observers
+- Different types of observers (displays and alert systems)
+- Easy addition of new observers
+
+## Mermaid Diagram
+
+The following diagram illustrates the structure and flow of the Stock Market Monitor using the Observer pattern:
+
+```mermaid
+classDiagram
+    class StockObserver {
+        <<interface>>
+        +update(symbol: str, price: f64)
+    }
+    class StockMarket {
+        -prices: HashMap<String, f64>
+        -observers: Vec<Rc<RefCell<dyn StockObserver>>>
+        +add_observer(observer: Rc<RefCell<dyn StockObserver>>)
+        +set_price(symbol: str, price: f64)
+        -notify_observers(symbol: str, price: f64)
+    }
+    class PriceDisplay {
+        -name: String
+        +update(symbol: str, price: f64)
+    }
+    class AlertSystem {
+        -threshold: f64
+        +update(symbol: str, price: f64)
+    }
+
+    StockMarket ..> StockObserver : notifies
+    PriceDisplay ..|> StockObserver
+    AlertSystem ..|> StockObserver
+```
+
+## How it works
+
+1. The `StockMarket` (subject) maintains a list of observers and current stock prices.
+2. Observers (`PriceDisplay` and `AlertSystem`) implement the `StockObserver` trait.
+3. When a stock price is updated via `set_price()`, all registered observers are notified.
+4. Each observer type handles the update differently:
+    - `PriceDisplay` simply displays the new price.
+    - `AlertSystem` checks if the price exceeds a threshold and issues an alert if it does.
+
+## Usage
+
+To use the Stock Market Monitor in your code:
+
+```rust
+let mut stock_market = StockMarket::new();
+
+let display = Rc::new(RefCell::new(PriceDisplay {
+    name: String::from("Main Display"),
+}));
+let alert = Rc::new(RefCell::new(AlertSystem {
+    threshold: 100.0,
+}));
+
+stock_market.add_observer(display);
+stock_market.add_observer(alert);
+
+// Update a stock price
+stock_market.set_price("AAPL", 150.0);
+```
+
+## Running the Example
+
+1. Ensure you have Rust installed.
+2. Clone this repository.
+3. Run `cargo run` to see the Stock Market Monitor in action.
+
+## Notes
+
+The Observer pattern is excellent for implementing distributed event handling systems. It's widely used in implementing distributed event handling systems, MVC architectural pattern, and in designing user interface toolkits. However, if overused, it can lead to complex systems where observers are difficult to track and maintain.

DesignModule04/StockMarket/Cargo.toml

@@ -0,0 +1,85 @@
+use std::collections::HashMap;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+// Observer trait
+trait StockObserver {
+    fn update(&self, symbol: &str, price: f64);
+}
+
+// Subject (Observable)
+struct StockMarket {
+    prices: HashMap<String, f64>,
+    observers: Vec<Rc<RefCell<dyn StockObserver>>>,
+}
+
+impl StockMarket {
+    fn new() -> Self {
+        StockMarket {
+            prices: HashMap::new(),
+            observers: Vec::new(),
+        }
+    }
+
+    fn add_observer(&mut self, observer: Rc<RefCell<dyn StockObserver>>) {
+        self.observers.push(observer);
+    }
+
+    fn set_price(&mut self, symbol: &str, price: f64) {
+        self.prices.insert(symbol.to_string(), price);
+        self.notify_observers(symbol, price);
+    }
+
+    fn notify_observers(&self, symbol: &str, price: f64) {
+        for observer in &self.observers {
+            observer.borrow().update(symbol, price);
+        }
+    }
+}
+
+// Concrete Observers
+struct PriceDisplay {
+    name: String,
+}
+
+impl StockObserver for PriceDisplay {
+    fn update(&self, symbol: &str, price: f64) {
+        println!("{}: {} stock updated to ${:.2}", self.name, symbol, price);
+    }
+}
+
+struct AlertSystem {
+    threshold: f64,
+}
+
+impl StockObserver for AlertSystem {
+    fn update(&self, symbol: &str, price: f64) {
+        if price > self.threshold {
+            println!("ALERT: {} stock price ${:.2} exceeds threshold ${:.2}", symbol, price, self.threshold);
+        }
+    }
+}
+
+fn main() {
+    let mut stock_market = StockMarket::new();
+
+    let display1 = Rc::new(RefCell::new(PriceDisplay {
+        name: String::from("Display 1"),
+    }));
+    let display2 = Rc::new(RefCell::new(PriceDisplay {
+        name: String::from("Display 2"),
+    }));
+    let alert_system = Rc::new(RefCell::new(AlertSystem {
+        threshold: 100.0,
+    }));
+
+    stock_market.add_observer(display1);
+    stock_market.add_observer(display2);
+    stock_market.add_observer(alert_system);
+
+    // Simulate stock price changes
+    stock_market.set_price("AAPL", 15.0);
+    stock_market.set_price("GOOGL", 1330.0);
+    stock_market.set_price("MSFT", 95.0);
+    stock_market.set_price("MSFT", 120.0);
+}

DesignModule04/StockMarket/Observer.jpg

@@ -0,0 +1,6 @@
+[package]
+name = "config_man"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]