Move free functions into UpdateFrom trait

2 files changed, 63 insertions, 55 deletions

diff --git a/src/lib.rs b/src/lib.rs
index e36a847..849d954 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -14,6 +14,10 @@ pub enum PrintStatus {
     Busy,
 }
 
+pub trait UpdateFrom<T> {
+    fn update_from(&mut self, source: &T);
+}
+
 #[derive(Debug, Default, Serialize, Clone)]
 pub struct PrinterState {
     pub status: PrintStatus,
@@ -88,6 +92,38 @@ pub struct PrusaStatus {
     printer: PrusaPrinterInfo,
 }
 
+impl UpdateFrom<PrusaStatus> for PrinterState {
+    fn update_from(&mut self, status: &PrusaStatus) {
+        self.status = match status.printer.state {
+            PrusaState::Idle => PrintStatus::Idle,
+            PrusaState::Printing => PrintStatus::Printing,
+            PrusaState::Paused => PrintStatus::Paused,
+            PrusaState::Finished => PrintStatus::Finished,
+            PrusaState::Stopped => PrintStatus::Stopped,
+            PrusaState::Error => PrintStatus::Error,
+            PrusaState::Attention => PrintStatus::Attention,
+            PrusaState::Busy => PrintStatus::Busy,
+        };
+        let p = &status.printer;
+        self.bed_temp = p.temp_bed;
+        self.target_bed_temp = p.target_bed;
+        self.nozzle_temp = p.temp_nozzle;
+        self.target_nozzle_temp = p.target_nozzle;
+        self.axis_x = p.axis_x;
+        self.axis_y = p.axis_y;
+        self.axis_z = p.axis_z;
+        self.flow = p.flow;
+        self.speed = p.speed;
+        self.fan_hotend = p.fan_hotend;
+        self.fan_print = p.fan_print;
+        if let Some(job) = &status.job {
+            self.progress = job.progress;
+            self.time_remaining = job.time_remaining;
+            self.time_printing = job.time_printing;
+        }
+    }
+}
+
 #[derive(Deserialize)]
 struct BambuPrintMessage {
     bed_target_temper: Option<f32>,
@@ -107,6 +143,31 @@ pub struct BambuStatus {
     print: Option<BambuPrintMessage>,
 }
 
+impl UpdateFrom<BambuStatus> for PrinterState {
+    fn update_from(&mut self, status: &BambuStatus) {
+        if let Some(print) = &status.print {
+            if let Some(v) = print.bed_temper { self.bed_temp = v; }
+            if let Some(v) = print.bed_target_temper { self.target_bed_temp = v; }
+            if let Some(v) = print.nozzle_temper { self.nozzle_temp = v; }
+            if let Some(v) = print.nozzle_target_temper { self.target_nozzle_temp = v; }
+            if let Some(v) = print.mc_percent { self.progress = v as f32; }
+            if let Some(v) = print.mc_remaining_time { self.time_remaining = v; }
+            if let Some(v) = print.layer_num { self.layer_num = v; }
+            if let Some(v) = print.total_layer_num { self.total_layer_num = v; }
+            if let Some(v) = &print.print_speed { self.print_speed = Some(v.clone()); }
+            if let Some(gcode_state) = &print.gcode_state {
+                self.status = match gcode_state {
+                    BambuState::Idle => PrintStatus::Idle,
+                    BambuState::Running => PrintStatus::Printing,
+                    BambuState::Pause => PrintStatus::Paused,
+                    BambuState::Finish => PrintStatus::Finished,
+                    BambuState::Failed => PrintStatus::Error,
+                };
+            }
+        }
+    }
+}
+
 #[derive(Debug, Deserialize)]
 pub struct Config {
     // This allows you to have a list of different printer types
@@ -134,56 +195,3 @@ pub enum Printer {
         serial_number: String,
     },
 }
-
-pub fn extract_status_from_prusa(status: &PrusaStatus, state: &mut PrinterState) {
-    state.status = match status.printer.state {
-        PrusaState::Idle => PrintStatus::Idle,
-        PrusaState::Printing => PrintStatus::Printing,
-        PrusaState::Paused => PrintStatus::Paused,
-        PrusaState::Finished => PrintStatus::Finished,
-        PrusaState::Stopped => PrintStatus::Stopped,
-        PrusaState::Error => PrintStatus::Error,
-        PrusaState::Attention => PrintStatus::Attention,
-        PrusaState::Busy => PrintStatus::Busy,
-    };
-    let p = &status.printer;
-    state.bed_temp = p.temp_bed;
-    state.target_bed_temp = p.target_bed;
-    state.nozzle_temp = p.temp_nozzle;
-    state.target_nozzle_temp = p.target_nozzle;
-    state.axis_x = p.axis_x;
-    state.axis_y = p.axis_y;
-    state.axis_z = p.axis_z;
-    state.flow = p.flow;
-    state.speed = p.speed;
-    state.fan_hotend = p.fan_hotend;
-    state.fan_print = p.fan_print;
-    if let Some(job) = &status.job {
-        state.progress = job.progress;
-        state.time_remaining = job.time_remaining;
-        state.time_printing = job.time_printing;
-    }
-}
-
-pub fn extract_status_from_bambu(status: &BambuStatus, state: &mut PrinterState) {
-    if let Some(print) = &status.print {
-        if let Some(v) = print.bed_temper { state.bed_temp = v; }
-        if let Some(v) = print.bed_target_temper { state.target_bed_temp = v; }
-        if let Some(v) = print.nozzle_temper { state.nozzle_temp = v; }
-        if let Some(v) = print.nozzle_target_temper { state.target_nozzle_temp = v; }
-        if let Some(v) = print.mc_percent { state.progress = v as f32; }
-        if let Some(v) = print.mc_remaining_time { state.time_remaining = v; }
-        if let Some(v) = print.layer_num { state.layer_num = v; }
-        if let Some(v) = print.total_layer_num { state.total_layer_num = v; }
-        if let Some(v) = &print.print_speed { state.print_speed = Some(v.clone()); }
-        if let Some(gcode_state) = &print.gcode_state {
-            state.status = match gcode_state {
-                BambuState::Idle => PrintStatus::Idle,
-                BambuState::Running => PrintStatus::Printing,
-                BambuState::Pause => PrintStatus::Paused,
-                BambuState::Finish => PrintStatus::Finished,
-                BambuState::Failed => PrintStatus::Error,
-            };
-        }
-    }
-}
diff --git a/src/main.rs b/src/main.rs
index f8af266..40da34e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -56,7 +56,7 @@ async fn fetch_prusa(
         .await?;
     let mut lock = state.lock().await;
     let entry = lock.entry(name.to_owned()).or_default();
-    extract_status_from_prusa(&response, entry);
+    entry.update_from(&response);
     Ok(())
 }
 
@@ -103,7 +103,7 @@ async fn poll_bambu(
                     Ok(msg) => {
                         let mut lock = state.lock().await;
                         let entry = lock.entry(name.clone()).or_default();
-                        extract_status_from_bambu(&msg, entry);
+                        entry.update_from(&msg);
                         tracing::debug!(name, payload = ?p.payload, "Updated state");
                     }
                     Err(e) => tracing::error!(error = %e, "Failed to deserialize BambuStatus"),