refactor container and stacked series

draw/src/container.rs

@@ -1,6 +1,6 @@
 pub struct Container {
     max_samples: u32,
-    pub data: Vec<Vec<f32>>, // TODO: make this private, pass iterator instead
+    data: Vec<Vec<f32>>,
 }
 
 impl Container {
@@ -17,4 +17,8 @@ impl Container {
         }
         self.data.push(data)
     }
+
+    pub fn iter(&self) -> std::slice::Iter<'_, Vec<f32>> {
+        self.data.iter()
+    }
 }

draw/src/lib.rs

@@ -1,3 +1,5 @@
+mod container;
 mod stacked;
 
+pub use container::Container;
 pub use stacked::{StackedConfig, StackedSeries, StackedSeriesConfig, stacked};

draw/src/stacked.rs

@@ -4,6 +4,8 @@ use imageproc::{
     rect::Rect,
 };
 
+use crate::Container;
+
 pub struct StackedConfig {
     pub width_px_per_sample: u32,
     pub height_px: u32,
@@ -15,12 +17,27 @@ pub struct StackedSeriesConfig {
     pub color: (u8, u8, u8),
 }
 
-pub struct StackedSeries<'a> {
-    pub config: &'a StackedConfig,
-    pub data: &'a Vec<Vec<f32>>,
+pub struct StackedSeries {
+    pub config: StackedConfig,
+    data: Container,
 }
 
-pub fn stacked(graph: StackedSeries) -> RgbImage {
+impl StackedSeries {
+    pub fn new(config: StackedConfig) -> StackedSeries {
+        let max_samples = config.max_samples;
+
+        StackedSeries {
+            config: config,
+            data: Container::new(max_samples),
+        }
+    }
+
+    pub fn push(&mut self, data: Vec<f32>) {
+        self.data.push(data);
+    }
+}
+
+pub fn stacked(graph: &StackedSeries) -> RgbImage {
     let mut image = RgbImage::new(
         graph.config.width_px_per_sample * graph.config.max_samples,
         graph.config.height_px as u32,
@@ -31,7 +48,7 @@ pub fn stacked(graph: StackedSeries) -> RgbImage {
 }
 
 /// return scale factor to scale stacked series sum to range 0..1
-fn get_scale(series: &Vec<Vec<f32>>) -> f32 {
+fn get_scale(series: &Container) -> f32 {
     let max = series
         .iter()
         .map(|s| s.iter().sum())
@@ -42,7 +59,7 @@ fn get_scale(series: &Vec<Vec<f32>>) -> f32 {
 }
 
 fn draw_scaled_graph(image: &mut RgbImage, graph: &StackedSeries) {
-    let scale = get_scale(graph.data);
+    let scale = get_scale(&graph.data);
     let colors = graph
         .config
         .series
@@ -52,7 +69,7 @@ fn draw_scaled_graph(image: &mut RgbImage, graph: &StackedSeries) {
 
     let mut x_offset = 0f32;
 
-    for point_in_time in graph.data {
+    for point_in_time in graph.data.iter() {
         let mut y_offset = graph.config.height_px as f32;
 
         let mut series_idx = 0usize;
@@ -77,11 +94,13 @@ mod test {
 
     #[test]
     fn test_get_scale() {
-        let conf = vec![
-            vec![1., 2., 3., 4., 5.],
-            vec![0., 1., 0., 0., 0.],
-            vec![0., 0., 0., 0., 5.],
-        ];
-        assert_eq!(get_scale(&conf), 0.1);
+        let mut c = Container::new(10);
+        c.push(vec![1., 0., 0.]);
+        c.push(vec![2., 1., 0.]);
+        c.push(vec![3., 0., 0.]);
+        c.push(vec![4., 0., 5.]);
+        c.push(vec![5., 0., 5.]);
+
+        assert_eq!(get_scale(&c), 0.1);
     }
 }

waybar-collectd/src/main.rs

@@ -1,7 +1,5 @@
-mod container;
 mod observables;
 
-use container::Container;
 use draw::{StackedConfig, StackedSeries, StackedSeriesConfig, stacked};
 use observables::CpuObservable;
 use protocol::Protocol;
@@ -22,15 +20,12 @@ fn main() {
     if let Ok(mut proto) = Protocol::new("/var/run/collectd-unixsock") {
         // loop {
         let cpu = CpuObservable::discover(&mut proto).unwrap();
-        let mut container = Container::new(cfg.max_samples);
+        let mut series = StackedSeries::new(cfg);
         for _ in 1..10 {
             let sample = cpu.sample(&mut proto).unwrap();
-            container.push(sample);
+            series.push(sample);
 
-            let img = stacked(StackedSeries {
-                config: &cfg,
-                data: &container.data,
-            });
+            let img = stacked(&series);
             img.save("bzn.png").unwrap();
 
             thread::sleep(time::Duration::from_secs(1));