Flyweight: encapsulate tree colors into tree.rs

"Reg-green" pallette.

Author: fadeevab

structural/flyweight/forest.rs

@@ -1,22 +1,25 @@
 mod tree;
 
-use draw::{Canvas, RGB};
+use draw::Canvas;
 use std::{collections::HashMap, rc::Rc};
 use tree::{Tree, TreeKind};
 
+pub use self::tree::TreeColor;
+
 #[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.
+    pub fn plant_tree(&mut self, x: u32, y: u32, color: TreeColor, name: String, data: String) {
+        // Here is the substance of the Flywheight Pattern:
+        // 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)));
+            .or_insert(Rc::new(TreeKind::new(color, name.clone(), data)));
 
         // A tree kind is referenced from each tree instance using `Rc` pointer.
         // `tree_kind.clone()` increases a reference counter instead of real cloning.

structural/flyweight/forest/tree.rs

@@ -1,53 +1,69 @@
 use std::rc::Rc;
 
-use draw::{Canvas, Color, Drawing, Shape, Style, RGB};
+use draw::{Canvas, Drawing, Shape, Style, RGB};
 
-pub struct Tree {
-    x: u32,
-    y: u32,
-    kind: Rc<TreeKind>,
+pub enum TreeColor {
+    Color1,
+    Color2,
+    TrunkColor,
 }
 
-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);
+impl TreeColor {
+    fn rgb(&self) -> RGB {
+        match self {
+            Self::Color1 => RGB::new(0x17, 0xd7, 0xa0),
+            Self::Color2 => RGB::new(0xd8, 0x21, 0x48),
+            Self::TrunkColor => RGB::new(0x15, 0x1d, 0x3b),
+        }
     }
 }
 
 pub struct TreeKind {
-    color: RGB,
+    color: TreeColor,
     _name: String,
     _data: String,
 }
 
 impl TreeKind {
-    pub fn new(name: String, color: RGB, data: String) -> Self {
+    pub fn new(color: TreeColor, _name: String, _data: String) -> Self {
         Self {
-            _name: name,
             color,
-            _data: data,
+            _name,
+            _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_xy(x.saturating_sub(2) as f32, y as f32)
             .with_shape(Shape::Rectangle {
-                width: 2,
+                width: 4,
                 height: 5,
             })
-            .with_style(Style::filled(Color::black()));
+            .with_style(Style::filled(TreeColor::TrunkColor.rgb()));
 
         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));
+            .with_style(Style::filled(self.color.rgb()));
 
         canvas.display_list.add(rect);
         canvas.display_list.add(circle);
     }
 }
+
+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);
+    }
+}

structural/flyweight/main.rs

@@ -1,9 +1,9 @@
 mod forest;
 
-use draw::{render, render::svg::SvgRenderer, Canvas, RGB};
+use draw::{render, render::svg::SvgRenderer, Canvas};
 use rand::Rng;
 
-use crate::forest::Forest;
+use crate::forest::{Forest, TreeColor};
 
 const CANVAS_SIZE: u32 = 500;
 const TREES_TO_DRAW: u32 = 100000;
@@ -18,16 +18,16 @@ fn main() {
         forest.plant_tree(
             rng.gen_range(0..CANVAS_SIZE),
             rng.gen_range(0..CANVAS_SIZE),
+            TreeColor::Color1,
             "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),
+            TreeColor::Color2,
             "Autumn Oak".into(),
-            RGB::new(0xff, 0xa5, 0), // Orange
             "Autumn Oak texture stub".into(),
         );
     }