Connected Report struct to the serialize function

Author: ArcadeCode

src/main.rs

@@ -2,5 +2,5 @@ use std::path::Path;
 mod yadm;
 
 fn main() {
-    yadm::serialize(Path::new("."))
+    yadm::serialize(Path::new("../"))
 }

src/yadm.rs

@@ -1,5 +1,3 @@
 pub mod report;
-pub use report::report::Report;
-
 pub mod serialize;
 pub use serialize::serialize;

src/yadm/report.rs

@@ -1,38 +1,125 @@
 use std::fmt;
+use std::path::PathBuf;
 use std::time::{Duration, Instant};
 
-pub mod report {
-    use super::*;
+pub struct Report {
+    pub target_path: PathBuf,
+    pub scan_start_at: Instant,
+    pub scan_duration: Duration,
+    pub scan_started: bool,
+    pub elements_found: usize,
 
-    pub struct Report {
-        pub target: String,
-        pub scan_start_at: Instant,
-        pub scan_duration: Duration,
-        pub elements_found: u64,
+    pub hashmap_parsing_start_at: Instant,
+    pub hashmap_parsing_duration: Duration,
+    pub hashmap_parsing_started: bool,
 
-        pub hashmap_parsing_start_at: Instant,
-        pub hashmap_parsing_duration: Duration,
+    pub msgpack_parsing_start_at: Instant,
+    pub msgpack_parsing_duration: Duration,
+    pub msgpack_parsing: bool,
 
-        pub msgpack_parsing_start_at: Instant,
-        pub msgpack_parsing_duration: Duration,
+    pub zstd_compression_start_at: Instant,
+    pub zstd_compression_duration: Duration,
+    pub zstd_compression: bool,
 
-        pub output_file_size: u64,
-        pub full_duration: Duration,
-        pub average_duration_by_file: u64,
-        pub average_size_by_file: u64,
+    pub output_file_size: usize,
+    pub full_duration: Duration,
+    pub average_duration_by_file: usize,
+    pub average_size_by_file: usize,
+}
+
+impl Report {
+    pub fn time_scan(&mut self) {
+        if self.scan_started {
+            self.scan_duration = Instant::now() - self.scan_start_at;
+        } else {
+            self.scan_started = true;
+        }
+    }
+    pub fn time_hashmap_parsing(&mut self) {
+        if self.hashmap_parsing_started {
+            self.hashmap_parsing_duration = Instant::now() - self.hashmap_parsing_start_at;
+        } else {
+            self.hashmap_parsing_started = true;
+        }
+    }
+    pub fn time_msgpack_parsing(&mut self) {
+        if self.msgpack_parsing {
+            self.msgpack_parsing_duration = Instant::now() - self.msgpack_parsing_start_at;
+        } else {
+            self.msgpack_parsing = true;
+        }
+    }
+    pub fn time_zstd_compression(&mut self) {
+        if self.zstd_compression {
+            self.zstd_compression_duration = Instant::now() - self.zstd_compression_start_at;
+        } else {
+            self.zstd_compression = true;
+        }
+    }
+
+    pub fn new(target_path: PathBuf) -> Self {
+        // We use `Instant::now()` as a neutral initialization value for all start timestamps.
+        // Although these fields will be overwritten later when their respective steps actually begin,
+        // `Instant` does not implement `Default`, and there is no way to create an "empty" Instant.
+        // Using a common `now` reference ensures the struct is fully initialized with valid values
+        // and avoids the need for Option<Instant>, which would add complexity and require unwrapping.
+        let now = Instant::now();
+        Report {
+            target_path: target_path.canonicalize().unwrap_or(target_path),
+            scan_start_at: now,
+            scan_duration: Duration::ZERO,
+            scan_started: false,
+            elements_found: usize::default(),
+
+            hashmap_parsing_start_at: now,
+            hashmap_parsing_duration: Duration::ZERO,
+            hashmap_parsing_started: false,
+
+            msgpack_parsing_start_at: now,
+            msgpack_parsing_duration: Duration::ZERO,
+            msgpack_parsing: false,
+
+            zstd_compression_start_at: now,
+            zstd_compression_duration: Duration::ZERO,
+            zstd_compression: false,
+
+            output_file_size: usize::default(),
+            full_duration: Duration::ZERO,
+            average_duration_by_file: usize::default(),
+            average_size_by_file: usize::default(),
+        }
     }
 
-    impl fmt::Display for Report {
-        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            write!(
-                f,
-                "Scan of {} found {} elements in {:?}",
-                self.target, self.elements_found, self.full_duration
-            )?;
+    pub fn close_report(&mut self) {
+        self.full_duration = self.scan_duration
+            + self.hashmap_parsing_duration
+            + self.msgpack_parsing_duration
+            + self.zstd_compression_duration;
 
-            write!(
-                f,
-                "
+        if self.elements_found > 0 {
+            let nanos = self.full_duration.as_nanos() / self.elements_found as u128;
+            self.average_duration_by_file = (nanos / 1_000_000) as usize; // en millisecondes
+            self.average_size_by_file = self.output_file_size / self.elements_found;
+        } else {
+            self.average_duration_by_file = 0;
+            self.average_size_by_file = 0;
+        }
+    }
+}
+
+impl fmt::Display for Report {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "Scan of {} found {} elements in {:?}",
+            self.target_path.to_str().unwrap(),
+            self.elements_found,
+            self.full_duration
+        )?;
+
+        write!(
+            f,
+            "
 === YADM report ===
 Target : {}
 Scan duration : {:.2}s
@@ -49,19 +136,18 @@ Output file size : {:.2} Mo
 Output file size : {:.2} Go
 ===================
 ",
-                self.target,
-                self.scan_duration.as_secs_f64(),
-                self.elements_found,
-                self.hashmap_parsing_duration.as_secs_f64(),
-                self.msgpack_parsing_duration.as_secs_f64(),
-                self.full_duration.as_secs_f64(),
-                self.average_duration_by_file,
-                self.average_size_by_file,
-                self.output_file_size,
-                self.output_file_size as f64 / 1024.0,
-                self.output_file_size as f64 / (1024.0 * 1024.0),
-                self.output_file_size as f64 / (1024.0 * 1024.0 * 1024.0),
-            )
-        }
+            self.target_path.to_str().unwrap(),
+            self.scan_duration.as_secs_f64(),
+            self.elements_found,
+            self.hashmap_parsing_duration.as_secs_f64(),
+            self.msgpack_parsing_duration.as_secs_f64(),
+            self.full_duration.as_secs_f64(),
+            self.average_duration_by_file,
+            self.average_size_by_file,
+            self.output_file_size,
+            self.output_file_size as f64 / 1024.0,
+            self.output_file_size as f64 / (1024.0 * 1024.0),
+            self.output_file_size as f64 / (1024.0 * 1024.0 * 1024.0),
+        )
     }
 }

src/yadm/serialize.rs

@@ -5,6 +5,8 @@ use std::path::{Path, PathBuf};
 use walkdir::WalkDir;
 use zstd;
 
+use super::report::Report;
+
 /// TODO: Faire la doc
 pub fn serialize(path: &Path) {
     // Step 1 : Getting all entities into the Path
@@ -57,15 +59,31 @@ pub fn serialize(path: &Path) {
         return file;
     }
 
+    // Report give some informations to know how good or bad this version of YADM was.
+    let mut report: Report = Report::new(path.to_path_buf());
+
     // We check if the path go to only one File to skip the WalkDir call if not needed.
     let hashmap: Vec<HashMap<String, String>> = if path.is_file() {
+        // Because we didn't scan a directory, we intialized
+        report.elements_found = 1;
+        report.time_hashmap_parsing();
         parsing_to_hashmap(&[path.to_path_buf()])
     } else {
-        parsing_to_hashmap(&scan_dir(path))
+        report.time_scan();
+        let entries: Vec<PathBuf> = scan_dir(path);
+        report.time_scan();
+        report.elements_found = entries.len();
+
+        report.time_hashmap_parsing();
+        parsing_to_hashmap(&entries)
     };
 
-    // Sérialisation MsgPack dans fichier temporaire
+    report.time_hashmap_parsing(); // Here we stop the timer
+
+    // Serialization into msgpack format
+    report.time_msgpack_parsing();
     serialize_to_msgpack(&hashmap);
+    report.time_msgpack_parsing();
 
     // Ouvrir le fichier sérialisé en lecture
     let mut uncompressed_file =
@@ -75,11 +93,16 @@ pub fn serialize(path: &Path) {
     let output_file =
         File::create("output.msgpack.zst").expect("Failed to create output compressed file");
 
+    report.time_zstd_compression();
     // Compresser du fichier sérialisé vers le fichier compressé avec un niveau de compression à 22 (max)
     zstd::stream::copy_encode(&mut uncompressed_file, output_file, 22).expect("Compression failed");
+    report.time_zstd_compression();
 
     match std::fs::remove_file(Path::new("output.msgpack.temp")) {
         Ok(_) => println!("Fichier supprimé avec succès !"),
         Err(e) => eprintln!("Erreur lors de la suppression du fichier : {}", e),
     }
+
+    report.close_report();
+    println!("{}", report);
 }