parallel travesal algorithm

Cargo.toml

@@ -24,6 +24,7 @@ name = "erd"
 path = "src/main.rs"
 
 [dependencies]
+ahash = "0.8.6"
 ansi_term = "0.12.1"
 anyhow = "1.0.75"
 chrono = { version = "0.4.24", default-features = false, features = ["clock", "std"] }

src/disk/mod.rs

@@ -1,8 +1,9 @@
-use crate::{error::prelude::*, user::enums::BytePresentation};
+use crate::user::enums::BytePresentation;
 use ignore::DirEntry;
 use std::{
     fmt::{self, Display},
-    fs::Metadata,
+    fs::{self, Metadata},
+    io,
     ops::AddAssign,
 };
 
@@ -92,35 +93,52 @@ impl Usage {
     /// Gets the word count. Words are delimited by a whitespace or a sequence of whitespaces.
     /// Directories are initialized to 0. The `follow` argument determines whether or not to query the
     /// symlink target, otherwise the symlink will have a word count of 0.
-    pub fn init_word_count(data: &DirEntry, metadata: &Metadata, follow: bool) -> Result<Self> {
+    pub fn init_word_count(
+        data: &DirEntry,
+        metadata: &Metadata,
+        follow: bool,
+    ) -> Result<Self, io::Error> {
         if metadata.is_dir() || (metadata.is_symlink() && !follow) {
             return Ok(Self::WordCount(0));
         }
 
-        let word_count = std::fs::read_to_string(data.path())
-            .into_report(ErrorCategory::Internal)
-            .map(|data| data.split_whitespace().count())?;
+        let word_count =
+            std::fs::read_to_string(data.path()).map(|data| data.split_whitespace().count())?;
 
-        u64::try_from(word_count)
-            .into_report(ErrorCategory::Internal)
-            .map(Self::WordCount)
+        let word_count = u64::try_from(word_count).map_or_else(
+            |e| {
+                log::warn!("Usage::init_word_count {e}");
+                Self::WordCount(word_count as u64)
+            },
+            Self::WordCount,
+        );
+
+        Ok(word_count)
     }
 
     /// Gets the line count. Lines are delimited by the new-line ASCII char. Directories are
     /// initialized to 0. The `follow` argument determines whether or not to query the symlink
     /// target, otherwise the symlink will have a count of 0.
-    pub fn init_line_count(data: &DirEntry, metadata: &Metadata, follow: bool) -> Result<Self> {
+    pub fn init_line_count(
+        data: &DirEntry,
+        metadata: &Metadata,
+        follow: bool,
+    ) -> Result<Self, io::Error> {
         if metadata.is_dir() || (metadata.is_symlink() && !follow) {
             return Ok(Self::LineCount(0));
         }
 
-        let line_count = std::fs::read_to_string(data.path())
-            .into_report(ErrorCategory::Internal)
-            .map(|data| data.lines().count())?;
+        let line_count = fs::read_to_string(data.path()).map(|data| data.lines().count())?;
+
+        let line_count = u64::try_from(line_count).map_or_else(
+            |e| {
+                log::warn!("Usage::init_line_count {e}");
+                Self::WordCount(line_count as u64)
+            },
+            Self::LineCount,
+        );
 
-        u64::try_from(line_count)
-            .into_report(ErrorCategory::Internal)
-            .map(Self::WordCount)
+        Ok(line_count)
     }
 
     /// Gets the underlying numeric value representing the disk usage

src/file/inode.rs

@@ -16,7 +16,7 @@ impl Inode {
 }
 
 #[derive(Debug, thiserror::Error)]
-#[error("Insufficient information to compute inode")]
+#[error("Insufficient information to compute inode.")]
 pub struct INodeError;
 
 impl TryFrom<&Metadata> for Inode {

src/file/mod.rs

@@ -1,17 +1,17 @@
 use crate::{
     disk,
-    error::prelude::*,
     user::{enums::Metric, Context},
 };
 use ignore::DirEntry;
 use std::{
     fs::{self, Metadata},
+    io,
     ops::Deref,
 };
 
 /// Concerned with querying information about a file's underlying inode.
 pub mod inode;
-use inode::Inode;
+use inode::{INodeError, Inode};
 
 /// Erdtree's wrapper around [`DirEntry`], it's metadata ([`Metadata`]). Also contains disk usage
 /// information of files. Directories will always be initialized to have a size of zero as they
@@ -42,13 +42,13 @@ impl File {
             follow,
             ..
         }: &Context,
-    ) -> Result<Self> {
+    ) -> Result<Self, io::Error> {
         let path = data.path();
 
         let metadata = if *follow {
-            fs::metadata(path).into_report(ErrorCategory::System)?
+            fs::metadata(path)?
         } else {
-            fs::symlink_metadata(path).into_report(ErrorCategory::System)?
+            fs::symlink_metadata(path)?
         };
 
         let size = match metric {
@@ -65,8 +65,8 @@ impl File {
     }
 
     /// Attempts to query the [`File`]'s underlying inode which is represented by [`Inode`].
-    pub fn inode(&self) -> Result<Inode> {
-        Inode::try_from(&self.metadata).into_report(ErrorCategory::Internal)
+    pub fn inode(&self) -> Result<Inode, INodeError> {
+        Inode::try_from(&self.metadata)
     }
 
     /// Gets a mutable reference to the `size` field.

src/main.rs

@@ -44,18 +44,12 @@ fn run() -> error::Result<()> {
         .transpose()?;
 
     let file_tree = if ctx.threads > 1 {
-        FileTree::init(&ctx)?
+        FileTree::init_parallel(&ctx)?
     } else {
         FileTree::init(&ctx)?
     };
 
-    let Some(indextree::NodeEdge::Start(id)) = file_tree.traverse().next() else {
-        panic!("womp");
-    };
-
-    let root = file_tree[id].get();
-
-    println!("{root:?}");
+    //println!("{}", file_tree[file_tree.root_id()].get().size().value());
 
     if let Some(logger) = logger {
         logger.flush();