Refactor: PAtomicInfo class

src/dir_walker.rs

@@ -4,7 +4,6 @@ use std::sync::Arc;
 use crate::node::Node;
 use crate::progress::Operation;
 use crate::progress::PAtomicInfo;
-use crate::progress::ThreadSyncTrait;
 use crate::progress::ORDERING;
 use crate::utils::is_filtered_out_due_to_invert_regex;
 use crate::utils::is_filtered_out_due_to_regex;
@@ -28,7 +27,7 @@ pub struct WalkData<'a> {
     pub by_filecount: bool,
     pub ignore_hidden: bool,
     pub follow_links: bool,
-    pub progress_data: Option<Arc<PAtomicInfo>>,
+    pub progress_data: Arc<PAtomicInfo>,
 }
 
 pub fn walk_it(dirs: HashSet<PathBuf>, walk_data: WalkData) -> Vec<Node> {
@@ -36,10 +35,11 @@ pub fn walk_it(dirs: HashSet<PathBuf>, walk_data: WalkData) -> Vec<Node> {
     let top_level_nodes: Vec<_> = dirs
         .into_iter()
         .filter_map(|d| {
+            let prog_data = &walk_data.progress_data;
+            prog_data.clear_state(&d);
             let node = walk(d, &walk_data, 0)?;
-            if let Some(data) = &walk_data.progress_data {
+
-                data.state.store(Operation::PREPARING, ORDERING);
+            prog_data.state.store(Operation::PREPARING, ORDERING);
-            }
             clean_inodes(node, &mut inodes, walk_data.use_apparent_size)
         })
         .collect();
@@ -124,18 +124,7 @@ fn ignore_file(entry: &DirEntry, walk_data: &WalkData) -> bool {
 }
 
 fn walk(dir: PathBuf, walk_data: &WalkData, depth: usize) -> Option<Node> {
-    let info_data = &walk_data.progress_data;
+    let prog_data = &walk_data.progress_data;
-
-    if let Some(data) = info_data {
-        data.state.store(Operation::INDEXING, ORDERING);
-        if depth == 0 {
-            data.current_path.set(dir.to_string_lossy().to_string());
-
-            // reset the value between each target dirs
-            data.total_file_size.store(0, ORDERING);
-            data.file_number.store(0, ORDERING);
-        }
-    }
 
     let mut children = vec![];
 
@@ -169,26 +158,22 @@ fn walk(dir: PathBuf, walk_data: &WalkData, depth: usize) -> Option<Node> {
                                 depth,
                             );
 
-                            if let Some(data) = info_data {
+                            prog_data.file_number.fetch_add(1, ORDERING);
-                                data.file_number.fetch_add(1, ORDERING);
                             if let Some(ref file) = node {
-                                    data.total_file_size.fetch_add(file.size, ORDERING);
+                                prog_data.total_file_size.fetch_add(file.size, ORDERING);
-                                }
                             }
 
                             return node;
                         }
                     }
-                } else if let Some(data) = &walk_data.progress_data {
+                } else {
-                    data.no_permissions.store(true, ORDERING)
+                    prog_data.no_permissions.store(true, ORDERING)
                 }
                 None
             })
             .collect();
     } else if !dir.is_file() {
-        if let Some(data) = &walk_data.progress_data {
+        walk_data.progress_data.no_permissions.store(true, ORDERING)
-            data.no_permissions.store(true, ORDERING)
-        }
     }
     build_node(
         dir,

src/main.rs

@@ -18,7 +18,6 @@ use progress::ORDERING;
 use std::collections::HashSet;
 use std::io::BufRead;
 use std::process;
-use std::sync::Arc;
 use sysinfo::{System, SystemExt};
 
 use self::display::draw_it;
@@ -173,18 +172,10 @@ fn main() {
 
     let ignore_hidden = config.get_ignore_hidden(&options);
 
-    let disable_progress = config.get_disable_progress(&options);
-
-    let info_indicator = if disable_progress {
-        None
-    } else {
     let mut indicator = PIndicator::build_me();
+    if !config.get_disable_progress(&options) {
         indicator.spawn(iso);
-        Some(indicator)
+    }
-    };
-
-    // Must be a cleaner way to do this
-    let tmp_data = info_indicator.as_ref().map(|i| Arc::clone(&i.data));
 
     let walk_data = WalkData {
         ignore_directories: ignored_full_path,
@@ -195,8 +186,7 @@ fn main() {
         by_filecount,
         ignore_hidden,
         follow_links,
-        // Maybe just arc::clone the whole PIndicator and send that down here:
+        progress_data: indicator.data.clone(),
-        progress_data: tmp_data,
     };
 
     let _rayon = init_rayon();
@@ -218,12 +208,10 @@ fn main() {
         }
     };
 
-    if let Some(info) = info_indicator {
+    if indicator.data.no_permissions.load(ORDERING) {
-        if info.data.no_permissions.load(ORDERING) {
         eprintln!("Did not have permissions for all directories");
     }
-        info.stop();
+    indicator.stop();
-    }
 
     if let Some(root_node) = tree {
         draw_it(

src/progress.rs

@@ -1,5 +1,6 @@
 use std::{
     io::Write,
+    path::Path,
     sync::{
         atomic::{AtomicBool, AtomicU64, AtomicU8, AtomicUsize, Ordering},
         Arc, RwLock,
@@ -56,6 +57,16 @@ pub struct PAtomicInfo {
     pub no_permissions: AtomicBool,
 }
 
+impl PAtomicInfo {
+    pub fn clear_state(&self, dir: &Path) {
+        self.state.store(Operation::INDEXING, ORDERING);
+        let dir_name = dir.to_string_lossy().to_string();
+        self.current_path.set(dir_name);
+        self.total_file_size.store(0, ORDERING);
+        self.file_number.store(0, ORDERING);
+    }
+}
+
 /* -------------------------------------------------------------------------- */
 fn format_indicator_str(data: &PAtomicInfo, progress_char_i: usize, status: &str) -> String {
     format!(