even more edge cases

examples/custom_handler.rs

@@ -32,7 +32,7 @@ impl GlobalData for HighestDamageHandler {
             ..
         }) = event
         {
-            let damage = damage.get();
+            let damage = *damage as u32;
             match &mut self.current {
                 Some((_, current_damage)) if damage > *current_damage => {
                     self.current = Some((subject, damage))

examples/dir.rs

@@ -1,4 +1,4 @@
-use indicatif::ParallelProgressIterator;
+use indicatif::{ParallelProgressIterator, ProgressBar, ProgressStyle};
 use main_error::MainError;
 use rayon::prelude::*;
 use std::env::args;
@@ -6,7 +6,7 @@ use std::ffi::OsStr;
 use std::fs;
 use std::hint::black_box;
 use std::sync::atomic::{AtomicUsize, Ordering};
-use std::time::Instant;
+use std::time::{Duration, Instant};
 use tf_log_parser::parse;
 use walkdir::WalkDir;
 
@@ -18,43 +18,71 @@ fn main() -> Result<(), MainError> {
     let count = AtomicUsize::default();
     let start = Instant::now();
 
-    WalkDir::new(path)
+    let style = ProgressStyle::with_template(
+        "[{elapsed_precise}] {wide_bar:.cyan/blue} {per_sec:!} {pos:>7}/{len:7}",
+    )
+    .unwrap();
+
+    let pb = ProgressBar::new_spinner();
+    pb.enable_steady_tick(Duration::from_millis(120));
+    pb.set_style(
+        ProgressStyle::with_template("[{elapsed_precise}] {spinner:.blue} {msg}")
+            .unwrap()
+            .tick_strings(&[
+                "▹▹▹▹▹",
+                "▸▹▹▹▹",
+                "▹▸▹▹▹",
+                "▹▹▸▹▹",
+                "▹▹▹▸▹",
+                "▹▹▹▹▸",
+                "▪▪▪▪▪",
+            ]),
+    );
+    pb.set_message("Collecting paths...");
+
+    let paths: Vec<_> = WalkDir::new(path)
         .into_iter()
         .flatten()
-        .par_bridge()
-        .progress_count(2_500_000)
-        .for_each(|entry| {
-            let path = entry.path();
-            if path.extension() == Some(OsStr::new("log")) {
-                // let _ = print!("{} - ", path.display());
-                let read_start = Instant::now();
-                let input = match fs::read_to_string(path) {
-                    Ok(input) => input,
-                    Err(_e) => {
-                        // println!("failed to read file: {}", e);
-                        return;
-                    }
-                };
+        .filter(|entry| entry.path().extension() == Some(OsStr::new("log")))
+        .collect();
 
-                read_time.fetch_add(read_start.elapsed().as_micros() as usize, Ordering::Relaxed);
-                let parse_start = Instant::now();
-                let (output, _) = match parse(&input) {
-                    Ok(val) => val,
-                    Err(e) => {
-                        eprintln!("failed to parse {}: {}", path.display(), e);
-                        return;
-                    }
-                };
+    pb.finish_with_message("Done");
 
-                parse_time.fetch_add(
-                    parse_start.elapsed().as_micros() as usize,
-                    Ordering::Relaxed,
-                );
-                count.fetch_add(1, Ordering::Relaxed);
-                black_box(output);
-                // let _ = println!("{} messages", output.chat.len());
-            }
-        });
+    let bar = ProgressBar::new(paths.len() as u64);
+    bar.set_style(style);
+
+    paths.into_par_iter().progress_with(bar).for_each(|entry| {
+        let path = entry.path();
+        if path.extension() == Some(OsStr::new("log")) {
+            // let _ = print!("{} - ", path.display());
+            let read_start = Instant::now();
+            let input = match fs::read_to_string(path) {
+                Ok(input) => input,
+                Err(_e) => {
+                    // println!("failed to read file: {}", e);
+                    return;
+                }
+            };
+
+            read_time.fetch_add(read_start.elapsed().as_micros() as usize, Ordering::Relaxed);
+            let parse_start = Instant::now();
+            let (output, _) = match parse(&input) {
+                Ok(val) => val,
+                Err(e) => {
+                    eprintln!("failed to parse {}: {}", path.display(), e);
+                    return;
+                }
+            };
+
+            parse_time.fetch_add(
+                parse_start.elapsed().as_micros() as usize,
+                Ordering::Relaxed,
+            );
+            count.fetch_add(1, Ordering::Relaxed);
+            black_box(output);
+            // let _ = println!("{} messages", output.chat.len());
+        }
+    });
 
     let total = start.elapsed();