refactor(ColumnData): Add implementation for f64() casting and string Display format

Author: tkornack

twinleaf-tools/src/bin/tio-monitor.rs

@@ -123,18 +123,19 @@ impl ColumnFormatter {
         desc_width: usize,
     ) -> std::io::Result<()> {
         use data::ColumnData;
-        let (fval, fmtval) = match col.value {
-            ColumnData::Int(x) => (x as f64, format!("{:10}      ", x)),
-            ColumnData::UInt(x) => (x as f64, format!("{:10}      ", x)),
-            ColumnData::Float(x) => (
-                x,
+
+        let fval = col.value.try_as_f64().unwrap_or(f64::NAN);
+        let fmtval = match col.value {
+            ColumnData::Int(x) => format!("{:10}      ", x),
+            ColumnData::UInt(x) => format!("{:10}      ", x),
+            ColumnData::Float(x) => {
                 if x.is_nan() {
                     format!("{:10}      ", x)
                 } else {
                     format!("{:15.4} ", x)
-                },
-            ),
-            ColumnData::Unknown => (f64::NAN, format!("{:>15} ", "unsupported")),
+                }
+            }
+            ColumnData::Unknown => format!("{:>15} ", "unsupported"),
         };
 
         stdout.queue(cursor::MoveToNextLine(1))?;

twinleaf-tools/src/bin/tio-tool.rs

@@ -1,7 +1,7 @@
 use tio::proto::DeviceRoute;
 use tio::proxy;
 use tio::util;
-use twinleaf::data::{ColumnData, DeviceDataParser};
+use twinleaf::data::{DeviceDataParser};
 use twinleaf::tio;
 use twinleaf_tools::{tio_opts, tio_parseopts};
 
@@ -515,16 +515,6 @@ fn log_data_dump(args: &[String]) -> Result<(), ()> {
     Ok(())
 }
 
-fn match_value(data: ColumnData) -> String {
-    let data_type = match data {
-        ColumnData::Int(x) => format!("{}", x),
-        ColumnData::UInt(x) => format!("{}", x),
-        ColumnData::Float(x) => format!("{}", x),
-        ColumnData::Unknown => "?".to_string(),
-    };
-    data_type
-}
-
 fn log_csv(args: &[String]) -> Result<(), ()> {
     let mut parser = DeviceDataParser::new(args.len() > 1);
     let id: u8 = args[1].parse().unwrap();
@@ -538,61 +528,33 @@ fn log_csv(args: &[String]) -> Result<(), ()> {
         .create(true)
         .open(path)
         .or(Err(()))?;
-    let mut streamhead: bool = false;
-    let mut first: bool = true;
+    
+    let mut header_written: bool = false;
 
     for path in &args[2..] {
         let mut rest: &[u8] = &std::fs::read(path).unwrap();
         while rest.len() > 0 {
             let (pkt, len) = tio::Packet::deserialize(rest).unwrap();
             rest = &rest[len..];
             for sample in parser.process_packet(&pkt) {
-                //match stream id
-                if sample.stream.stream_id == id as u8 {
-                    //iterate through values
-                    for col in &sample.columns {
-                        let time = format!("{:.6}", sample.timestamp_end());
-                        let value = match_value(col.value.clone());
-
-                        //write in column names
-                        if !streamhead {
-                            let timehead = format!("{},", "time");
-                            let _ = file.write_all(timehead.as_bytes());
-
-                            for col in &sample.columns {
-                                let mut header = format!("{},", col.desc.name);
-
-                                if col.desc.name
-                                    == sample.columns[&sample.columns.len() - 1].desc.name.clone()
-                                {
-                                    header = format!("{}", col.desc.name);
-                                }
-
-                                file.write_all(header.as_bytes()).or(Err(()))?;
-                            }
-                            file.write_all(b"\n").or(Err(()))?;
-                            streamhead = true;
-                        }
-
-                        //write in data
-                        let timefmt = format!("{},", time);
-                        let mut formatted_value = format!("{},", value);
-                        if first {
-                            let _ = file.write_all(timefmt.as_bytes());
-                            first = false;
-                        }
-
-                        if value
-                            == match_value(sample.columns[&sample.columns.len() - 1].value.clone())
-                        {
-                            formatted_value = format!("{}", value);
-                        }
-
-                        file.write_all(formatted_value.as_bytes()).or(Err(()))?;
-                    }
-                    file.write_all(b"\n").or(Err(()))?;
-                    first = true;
+                if sample.stream.stream_id != id {
+                    continue;
                 }
+
+                if !header_written {
+                    let mut headers: Vec<String> = vec!["time".to_string()];
+                    headers.extend(sample.columns.iter().map(|col| col.desc.name.clone()));
+                    
+                    writeln!(file, "{}", headers.join(",")).or(Err(()))?;
+                    header_written = true;
+                }
+
+                let mut values: Vec<String> = Vec::new();
+                values.push(format!("{:.6}", sample.timestamp_end()));
+                
+                values.extend(sample.columns.iter().map(|col| col.value.to_string()));
+
+                writeln!(file, "{}", values.join(",")).or(Err(()))?;
             }
         }
     }

twinleaf/src/data/sample.rs

@@ -11,6 +11,28 @@ pub enum ColumnData {
     Unknown,
 }
 
+impl ColumnData {
+    pub fn try_as_f64(&self) -> Option<f64> {
+        match *self {
+            ColumnData::Int(i) => Some(i as f64),
+            ColumnData::UInt(u) => Some(u as f64),
+            ColumnData::Float(f) => Some(f),
+            ColumnData::Unknown => None,
+        }
+    }
+}
+
+impl std::fmt::Display for ColumnData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match *self {
+            ColumnData::Int(x) => write!(f, "{}", x),
+            ColumnData::UInt(x) => write!(f, "{}", x),
+            ColumnData::Float(x) => write!(f, "{}", x),
+            ColumnData::Unknown => write!(f, "?"),
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct Column {
     pub value: ColumnData,
@@ -100,17 +122,7 @@ impl std::fmt::Display for Sample {
             self.timestamp_end()
         )?;
         for col in &self.columns {
-            write!(
-                f,
-                " {}: {}",
-                col.desc.name,
-                match col.value {
-                    ColumnData::Int(x) => format!("{}", x),
-                    ColumnData::UInt(x) => format!("{}", x),
-                    ColumnData::Float(x) => format!("{}", x),
-                    ColumnData::Unknown => "?".to_string(),
-                }
-            )?;
+            write!(f, " {}: {}", col.desc.name, col.value)?;
         }
         write!(f, " [#{}]", self.n)
     }