1 files changed, 70 insertions, 5 deletions

diff --git a/src/result.rs b/src/result.rs
index 22a49a0..cce5d2d 100644
--- a/src/result.rs
+++ b/src/result.rs
@@ -1,10 +1,14 @@
 use chrono::prelude::*;
 use git_testament::{git_testament, render_testament};
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
+use std::fs::File;
+use std::iter::FromIterator;
+use std::path::{Path, PathBuf};
 
 git_testament!(TESTAMENT);
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Deserialize, Serialize)]
 pub struct SuiteMeasurements {
     measurements: Vec<OpMeasurements>,
     obnam_version: String,
@@ -15,21 +19,21 @@ pub struct SuiteMeasurements {
     host_ram: u64,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct OpMeasurements {
     benchmark: String,
     op: Operation,
     measurements: Vec<Measurement>,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 pub enum Measurement {
     TotalFiles(u64),
     TotalData(u64),
     DurationMs(u128),
 }
 
-#[derive(Debug, Clone, Copy, Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Deserialize, Serialize)]
 pub enum Operation {
     Start,
     Stop,
@@ -53,6 +57,12 @@ pub enum SuiteMeasurementsError {
 
     #[error("failed to get hostname: {0}")]
     Hostname(nix::Error),
+
+    #[error("failed to open result file {0} for reading: {1}")]
+    Open(PathBuf, std::io::Error),
+
+    #[error("failed to read result file {0}: {1}")]
+    Read(PathBuf, serde_json::Error),
 }
 
 impl SuiteMeasurements {
@@ -74,6 +84,14 @@ impl SuiteMeasurements {
         })
     }
 
+    pub fn from_file(filename: &Path) -> Result<Self, SuiteMeasurementsError> {
+        let data = File::open(filename)
+            .map_err(|err| SuiteMeasurementsError::Open(filename.to_path_buf(), err))?;
+        let m: Self = serde_json::from_reader(&data)
+            .map_err(|err| SuiteMeasurementsError::Read(filename.to_path_buf(), err))?;
+        Ok(m)
+    }
+
     pub fn hostname(&self) -> &str {
         &self.hostname
     }
@@ -82,9 +100,35 @@ impl SuiteMeasurements {
         &self.benchmark_started
     }
 
+    pub fn cpus(&self) -> usize {
+        self.host_cpus
+    }
+
+    pub fn ram(&self) -> u64 {
+        self.host_ram
+    }
+
+    pub fn obnam_version(&self) -> &str {
+        self.obnam_version
+            .strip_prefix("obnam-backup ")
+            .or(Some(""))
+            .unwrap()
+    }
+
     pub fn push(&mut self, m: OpMeasurements) {
         self.measurements.push(m);
     }
+
+    pub fn benchmark_names(&self) -> Vec<String> {
+        let names: HashSet<&str> = HashSet::from_iter(self.measurements.iter().map(|m| m.name()));
+        let mut names: Vec<String> = names.iter().map(|x| x.to_string()).collect();
+        names.sort();
+        names
+    }
+
+    pub fn ops(&self) -> impl Iterator<Item = &OpMeasurements> {
+        self.measurements.iter()
+    }
 }
 
 impl OpMeasurements {
@@ -97,7 +141,28 @@ impl OpMeasurements {
         }
     }
 
+    pub fn name(&self) -> &str {
+        &self.benchmark
+    }
+
     pub fn push(&mut self, m: Measurement) {
         self.measurements.push(m);
     }
+
+    pub fn op(&self) -> Operation {
+        self.op
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &Measurement> {
+        self.measurements.iter()
+    }
+
+    pub fn millis(&self) -> u128 {
+        for m in self.iter() {
+            if let Measurement::DurationMs(ms) = m {
+                return *ms;
+            }
+        }
+        0
+    }
 }