Abstract Factory: full decoupling of traits and implementations

Author: fadeevab

Cargo.toml

@@ -11,7 +11,8 @@ members = [
   "behavioral/strategy",
   "behavioral/template-method",
   "behavioral/visitor",
-  "creational/abstract-factory",
+  "creational/abstract-factory/app",
+  "creational/abstract-factory/app-dyn",
   "creational/builder",
   "creational/factory-method/maze-game",
   "creational/factory-method/render-dialog",

creational/abstract-factory/Cargo.toml

@@ -5,18 +5,40 @@ without specifying their concrete classes._
 
 ## GUI Factory Example
 
-There is a GUI Factory trait and two implementations: Windows and Mac OS factories. A factory can create buttons and checkboxes, however, depending on
-thr factory subtype, it will create either Windows or Mac OS components.
+This example shows a GUI framework can organize its classes into independent
+libraries:
+
+1. The `gui` library defines interfaces for all the components.
+   It has no external dependencies.
+2. The `windows` library provides Windows implementation of the base GUI.
+   Depends on `gui`.
+3. The `macos` library provides Mac OS implementation of the base GUI.
+   Depends on `gui`.
+
+The `app` is a client application that can use several implementations of the
+GUI framework, depending on the current environment or configuration.
+However, most of the `app` code _**doesn't depend on specific types of GUI
+elements**_. All the client code works with GUI elements through abstract
+interfaces (traits) defined by the `gui` lib.
 
 There are also 2 approaches to implementing abstract factory in Rust:
-using generics and using dynamic allocation.
+using generics (_static dispatch_) and using dynamic allocation
+(_dynamic dispatch_).
 
-## `main.rs`
+## `app/main.rs`
 
 Here, abstract factory is implemented via **generics** which allow the compiler
-to create a code that doesn't require dynamic dispatch in runtime.
+to create a code that does NOT require dynamic dispatch in runtime.
 
-See `GuiFactory` in [gui/mod.rs](gui/mod.rs).
+```rust
+pub trait GuiFactory {
+    type B: Button;
+    type C: Checkbox;
+
+    fn create_button(&self) -> Self::B;
+    fn create_checkbox(&self) -> Self::C;
+}
+```
 
 ### How to Run
 
@@ -33,12 +55,17 @@ Windows checkbox has switched
 Windows checkbox has switched
 ```
 
-## `main_dyn.rs`
+## `app/main_dyn.rs`
 
 If a concrete type of abstract factory is not known at the compilation time,
 then is should be implemented using `Box` pointers.
 
-See See `GuiFactoryDynamic` in [gui/mod.rs](gui/mod.rs).
+```rust
+pub trait GuiFactoryDynamic {
+    fn create_button(&self) -> Box<dyn Button>;
+    fn create_checkbox(&self) -> Box<dyn Checkbox>;
+}
+```
 
 ### How to Run
 

creational/abstract-factory/README.md

@@ -0,0 +1,13 @@
+[package]
+edition = "2021"
+name = "abstract_factory-dyn"
+version = "0.1.0"
+
+[[bin]]
+name = "abstract-factory-dyn"
+path = "main.rs"
+
+[dependencies]
+gui = {path = "../gui", version = "0.1.0"}
+macos-gui = {path = "../macos-gui", version = "0.1.0"}
+windows-gui = {path = "../windows-gui", version = "0.1.0"}

creational/abstract-factory/app-dyn/Cargo.toml

@@ -0,0 +1,25 @@
+mod render;
+
+use render::render;
+
+use gui::GuiFactoryDynamic;
+use macos_gui::factory::MacFactory;
+use windows_gui::factory::WindowsFactory;
+
+fn main() {
+    let windows = false;
+
+    // Allocate a factory object in runtime depending on unpredictable input.
+    let factory: &dyn GuiFactoryDynamic = if windows {
+        &WindowsFactory
+    } else {
+        &MacFactory
+    };
+
+    // Factory invocation can be inlined right here.
+    let button = factory.create_button();
+    button.press();
+
+    // Factory object can be passed to a function as a parameter.
+    render(factory);
+}

creational/abstract-factory/app-dyn/main.rs

@@ -0,0 +1,17 @@
+//! The code demonstrates that it doesn't depend on a concrete
+//! factory implementation.
+
+use gui::GuiFactoryDynamic;
+
+/// Renders GUI.
+pub fn render(factory: &dyn GuiFactoryDynamic) {
+    let button1 = factory.create_button();
+    let button2 = factory.create_button();
+    let checkbox1 = factory.create_checkbox();
+    let checkbox2 = factory.create_checkbox();
+
+    button1.press();
+    button2.press();
+    checkbox1.switch();
+    checkbox2.switch();
+}

creational/abstract-factory/app-dyn/render.rs

@@ -0,0 +1,13 @@
+[package]
+edition = "2021"
+name = "abstract_factory"
+version = "0.1.0"
+
+[[bin]]
+name = "abstract-factory"
+path = "main.rs"
+
+[dependencies]
+gui = {path = "../gui", version = "0.1.0"}
+macos-gui = {path = "../macos-gui", version = "0.1.0"}
+windows-gui = {path = "../windows-gui", version = "0.1.0"}

creational/abstract-factory/app/Cargo.toml

@@ -0,0 +1,16 @@
+mod render;
+
+use render::render;
+
+use macos_gui::factory::MacFactory;
+use windows_gui::factory::WindowsFactory;
+
+fn main() {
+    let windows = true;
+
+    if windows {
+        render(WindowsFactory);
+    } else {
+        render(MacFactory);
+    }
+}

creational/abstract-factory/app/main.rs

@@ -0,0 +1,20 @@
+//! The code demonstrates that it doesn't depend on a concrete
+//! factory implementation.
+
+use gui::GuiFactory;
+
+// Renders GUI. Factory object must be passed as a parameter to such the
+// generic function with factory invocation to utilize static dispatch.
+pub fn render(factory: impl GuiFactory) {
+    let button1 = factory.create_button();
+    let button2 = factory.create_button();
+    let checkbox1 = factory.create_checkbox();
+    let checkbox2 = factory.create_checkbox();
+
+    use gui::{Button, Checkbox};
+
+    button1.press();
+    button2.press();
+    checkbox1.switch();
+    checkbox2.switch();
+}

creational/abstract-factory/app/render.rs

@@ -0,0 +1,7 @@
+[package]
+edition = "2021"
+name = "gui"
+version = "0.1.0"
+
+[lib]
+path = "lib.rs"