Flyweight Pattern: Render a Forest

Author: fadeevab

Cargo.toml

@@ -14,4 +14,5 @@ members = [
   "structural/composite",
   "structural/decorator",
   "structural/facade",
+  "structural/flyweight",
 ]

structural/flyweight/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+edition = "2021"
+name = "flyweight"
+version = "0.1.0"
+
+[[bin]]
+name = "flyweight"
+path = "main.rs"
+
+[dependencies]
+draw = "0.3"
+rand = "0.8"

structural/flyweight/README.md

@@ -0,0 +1,27 @@
+# Flyweight
+
+## Rendering a Forest
+
+```bash
+cargo run --release
+```
+
+## Screenshot
+
+_res/forest.svg_ (10,000 trees):
+
+![Rendered Forest](res/forest.svg)
+
+## RAM usage stats
+
+For 100,000 trees:
+
+```
+100000 trees drawn
+---------------------
+Memory usage:
+Tree size (16 bytes) * 100000
++ TreeKind size (~30 bytes) * 2
+---------------------
+Total: 1MB (instead of 4MB)
+```

structural/flyweight/forest.rs

@@ -0,0 +1,32 @@
+mod tree;
+
+use draw::{Canvas, RGB};
+use std::{collections::HashMap, rc::Rc};
+use tree::{Tree, TreeKind};
+
+#[derive(Default)]
+pub struct Forest {
+    pub tree_kinds: HashMap<String, Rc<TreeKind>>,
+    pub trees: Vec<Tree>,
+}
+
+impl Forest {
+    pub fn plant_tree(&mut self, x: u32, y: u32, name: String, color: RGB, data: String) {
+        // Here is the "trick": there is always a single instance of a "tree kind" structure.
+        let tree_kind = self
+            .tree_kinds
+            .entry(name.clone())
+            .or_insert(Rc::new(TreeKind::new(name.clone(), color, data)));
+
+        // A tree kind is referenced from each tree instance using `Rc` pointer.
+        // `tree_kind.clone()` increases a reference counter instead of real cloning.
+        let tree = Tree::new(x, y, tree_kind.clone());
+        self.trees.push(tree);
+    }
+
+    pub fn draw(&self, canvas: &mut Canvas) {
+        for tree in &self.trees {
+            tree.draw(canvas);
+        }
+    }
+}

structural/flyweight/forest/tree.rs

@@ -0,0 +1,53 @@
+use std::rc::Rc;
+
+use draw::{Canvas, Color, Drawing, Shape, Style, RGB};
+
+pub struct Tree {
+    x: u32,
+    y: u32,
+    kind: Rc<TreeKind>,
+}
+
+impl Tree {
+    pub fn new(x: u32, y: u32, kind: Rc<TreeKind>) -> Self {
+        Self { x, y, kind }
+    }
+
+    pub fn draw(&self, canvas: &mut Canvas) {
+        self.kind.draw(canvas, self.x, self.y);
+    }
+}
+
+pub struct TreeKind {
+    color: RGB,
+    _name: String,
+    _data: String,
+}
+
+impl TreeKind {
+    pub fn new(name: String, color: RGB, data: String) -> Self {
+        Self {
+            _name: name,
+            color,
+            _data: data,
+        }
+    }
+
+    pub fn draw(&self, canvas: &mut Canvas, x: u32, y: u32) {
+        let rect = Drawing::new()
+            .with_xy(x.saturating_sub(1) as f32, y as f32)
+            .with_shape(Shape::Rectangle {
+                width: 2,
+                height: 5,
+            })
+            .with_style(Style::filled(Color::black()));
+
+        let circle = Drawing::new()
+            .with_xy(x as f32, y.saturating_sub(5) as f32)
+            .with_shape(Shape::Circle { radius: 5 })
+            .with_style(Style::filled(self.color));
+
+        canvas.display_list.add(rect);
+        canvas.display_list.add(circle);
+    }
+}

structural/flyweight/main.rs

@@ -0,0 +1,51 @@
+mod forest;
+
+use draw::{render, render::svg::SvgRenderer, Canvas, RGB};
+use rand::Rng;
+
+use crate::forest::Forest;
+
+const CANVAS_SIZE: u32 = 500;
+const TREES_TO_DRAW: u32 = 100000;
+const TREE_TYPES: u32 = 2;
+
+fn main() {
+    let forest = &mut Forest::default();
+
+    for _ in 0..TREES_TO_DRAW / TREE_TYPES {
+        let mut rng = rand::thread_rng();
+
+        forest.plant_tree(
+            rng.gen_range(0..CANVAS_SIZE),
+            rng.gen_range(0..CANVAS_SIZE),
+            "Summer Oak".into(),
+            RGB::new(0, 0xff, 0), // Green
+            "Oak texture stub".into(),
+        );
+
+        forest.plant_tree(
+            rng.gen_range(0..CANVAS_SIZE),
+            rng.gen_range(0..CANVAS_SIZE),
+            "Autumn Oak".into(),
+            RGB::new(0xff, 0xa5, 0), // Orange
+            "Autumn Oak texture stub".into(),
+        );
+    }
+
+    let mut canvas = Canvas::new(CANVAS_SIZE, CANVAS_SIZE);
+    forest.draw(&mut canvas);
+
+    render::save(&canvas, "res/forest.svg", SvgRenderer::new()).expect("Rendering");
+
+    println!("{} trees drawn", TREES_TO_DRAW);
+    println!("---------------------");
+    println!("Memory usage:");
+    println!("Tree size (16 bytes) * {}", TREES_TO_DRAW);
+    println!("+ TreeKind size (~30 bytes) * {}", TREE_TYPES);
+    println!("---------------------");
+    println!(
+        "Total: {}MB (instead of {}MB)",
+        ((TREES_TO_DRAW * 16 + TREE_TYPES * 30) / 1024 / 1024),
+        ((TREES_TO_DRAW * 46) / 1024 / 1024)
+    );
+}