command

README.md

@@ -20,6 +20,8 @@
 |:-------:|:----------- |:------:|
 | [Strategy](/behavioral/strategy.rs) | Enables an algorithm's behavior to be selected at runtime | ✔ |
 | [State](/behavioral/state.rs) | Encapsulates varying behavior for the same object based on its internal state | ✔ |
+| [Command](/behavioral/command.rs) | Bundles a command and arguments to call later | ✔ |
+
 
 
 ## Structural Patterns

behavioral/command.rs

@@ -0,0 +1,87 @@
+//! Each action is encapsulated into a struct with the trait Command
+
+use std::collections::HashMap;
+
+trait Command {
+    fn execute(&self);
+}
+
+#[derive(Copy, Clone)]
+struct TV;
+impl TV {
+    fn new() -> TV {
+        TV
+    }
+    fn on(&self) {
+        println!("TV is on, watch movies.");
+    }
+    fn off(&self) {
+        println!("TV is off");
+    }
+}
+
+struct TVOnCommand {
+    tv: TV,
+}
+
+impl TVOnCommand {
+    fn new(tv: TV) -> TVOnCommand {
+        TVOnCommand { tv }
+    }
+}
+
+impl Command for TVOnCommand {
+    fn execute(&self) {
+        self.tv.on();
+    }
+}
+
+struct TVOffCommand {
+    tv: TV,
+}
+
+impl TVOffCommand {
+    fn new(tv: TV) -> TVOffCommand {
+        TVOffCommand { tv }
+    }
+}
+
+impl Command for TVOffCommand {
+    fn execute(&self) {
+        self.tv.off();
+    }
+}
+
+struct TVRemoteControl {
+    commands: HashMap<i32, Box<dyn Command>>,
+}
+
+impl TVRemoteControl {
+    fn new() -> TVRemoteControl {
+        TVRemoteControl {
+            commands: HashMap::new(),
+        }
+    }
+    fn set_command(&mut self, idx: i32, cmd: Box<dyn Command>) {
+        self.commands.insert(idx, cmd);
+    }
+    fn press_button(&self, idx: i32) {
+        if let Some(cmd) = self.commands.get(&idx) {
+            cmd.execute();
+        } else {
+            println!("do nothing.");
+        }
+    }
+}
+
+fn main() {
+    let tv = TV::new();
+    let mut remote_control = TVRemoteControl::new();
+    remote_control.press_button(0);
+
+    remote_control.set_command(1, Box::new(TVOnCommand::new(tv)));
+    remote_control.set_command(2, Box::new(TVOffCommand::new(tv)));
+
+    remote_control.press_button(1);
+    remote_control.press_button(2);
+}

behavioral/state.rs

@@ -1,11 +1,11 @@
-// State is a behavioral design pattern that lets an object alter its behavior when its internal state changes.
-// It appears as if the object changed its class.
+//! State is a behavioral design pattern that lets an object alter its behavior when its internal state changes.
+//! It appears as if the object changed its class.
 
-// We’ll implement a blog post workflow
-// 1. A blog post starts as an empty draft.
-// 2. When the draft is done, a review of the post is requested.
-// 3. When the post is approved, it gets published.
-// 4. Only published blog posts return content to print, so unapproved posts can’t accidentally be published.
+//! We’ll implement a blog post workflow
+//! 1. A blog post starts as an empty draft.
+//! 2. When the draft is done, a review of the post is requested.
+//! 3. When the post is approved, it gets published.
+//! 4. Only published blog posts return content to print, so unapproved posts can’t accidentally be published.
 
 trait State {
     fn request_review(self: Box<Self>) -> Box<dyn State>;

creational/abstract_factory.rs

@@ -1,6 +1,4 @@
-/*
-Abstract Factory is a creational design pattern that lets you produce families of related objects without specifying their concrete classes.
-*/
+//! Abstract Factory is a creational design pattern that lets you produce families of related objects without specifying their concrete classes.
 
 trait GUIFactory {
     fn create_button(&self) -> Box<dyn Button>;

creational/builder.rs

@@ -1,6 +1,5 @@
-/*
-Builder is a creational design pattern, which allows constructing complex objects step by step.
-*/
+//! Builder is a creational design pattern, which allows constructing complex objects step by step.
+
 #[derive(Clone)]
 struct Product {
     parts: Vec<String>,
@@ -60,10 +59,6 @@ impl Builder for ContreteBuilder1 {
     }
     fn get_product(&mut self) -> Product {
         let p = self.product.clone();
-        // Product {
-        //     parts: self.product.parts.clone(),
-        //     ..self.product
-        // };
         self.product = Product::new();
         p
     }

creational/factory.rs

@@ -1,6 +1,4 @@
-/*
-Factory method creational design pattern allows creating objects without having to specify the exact type of the object that will be created.
-*/
+//! Factory method creational design pattern allows creating objects without having to specify the exact type of the object that will be created.
 
 trait Shape {
     fn draw(&self);

creational/singleton.rs

@@ -21,7 +21,7 @@ fn get_config() -> Arc<Mutex<Config>> {
 fn main() {
     let f1 = get_config();
     println!("{:?}", f1);
-    // modify 
+    // modify
     {
         let mut conf = f1.lock().unwrap();
         conf.db_connection_str = "hello".to_string();

structural/decorator.rs

@@ -33,9 +33,7 @@ struct ConcreteDecoratorA {
 
 impl Decorator for ConcreteDecoratorA {
     fn new(component: Rc<dyn Component>) -> Self {
-        ConcreteDecoratorA {
-            component,
-        }
+        ConcreteDecoratorA { component }
     }
 }
 
@@ -51,9 +49,7 @@ struct ConcreteDecoratorB {
 
 impl Decorator for ConcreteDecoratorB {
     fn new(component: Rc<dyn Component>) -> Self {
-        ConcreteDecoratorB {
-            component,
-        }
+        ConcreteDecoratorB { component }
     }
 }
 
@@ -84,5 +80,4 @@ fn main() {
 
     let decorator_a2 = ConcreteDecoratorB::new(Rc::new(decorator_a1));
     Client::client_code(&decorator_a2);
-
 }