perf!: do not create copies of dir entries

Author: KSXGitHub

src/fs_tree_builder.rs

@@ -6,6 +6,7 @@ use super::{
     size,
     tree_builder::{Info, TreeBuilder},
 };
+use pipe_trait::Pipe;
 use std::{
     fs::{read_dir, symlink_metadata},
     path::PathBuf,
@@ -65,51 +66,55 @@ where
             max_depth,
         } = builder;
 
-        TreeBuilder::<PathBuf, OsStringDisplay, Size, _, _> {
+        TreeBuilder::<PathBuf, _, Size, _, _> {
             name: OsStringDisplay::os_string_from(&root),
 
             path: root,
 
             get_info: |path| {
+                let make_info = |size: Size, children: Option<_>| Info {
+                    size,
+                    children: children.into_iter().flatten(),
+                };
+
+                let empty_info = || make_info(Size::default(), None);
+
                 let stats = match symlink_metadata(path) {
                     Err(error) => {
                         reporter.report(Event::EncounterError(ErrorReport {
                             operation: SymlinkMetadata,
                             path,
                             error,
                         }));
-                        return Info {
-                            size: Size::default(),
-                            children: Vec::new(),
-                        };
+                        return empty_info();
                     }
                     Ok(stats) => stats,
                 };
 
-                let children: Vec<_> = if stats.is_dir() {
+                let children = if stats.is_dir() {
                     match read_dir(path) {
                         Err(error) => {
                             reporter.report(Event::EncounterError(ErrorReport {
                                 operation: ReadDirectory,
                                 path,
                                 error,
                             }));
-                            return Info::default();
+                            return empty_info();
                         }
                         Ok(entries) => entries,
                     }
                     .flatten()
                     .map(|entry| entry.file_name())
                     .map(OsStringDisplay::from)
-                    .collect()
+                    .pipe(Some)
                 } else {
-                    Vec::new()
+                    None
                 };
 
                 let size = size_getter.get_size(&stats);
                 reporter.report(Event::ReceiveData(size));
 
-                Info { size, children }
+                make_info(size, children)
             },
 
             join_path: |prefix, name| prefix.join(&name.0),

src/tree_builder.rs

@@ -7,18 +7,20 @@ use rayon::prelude::*;
 
 /// Collection of functions and starting points in order to build a [`DataTree`] with [`From`] or [`Into`].
 #[derive(Debug)]
-pub struct TreeBuilder<Path, Name, Size, GetInfo, JoinPath>
+pub struct TreeBuilder<Path, NameIter, Size, GetInfo, JoinPath>
 where
     Path: Send + Sync,
-    Name: Send + Sync,
-    GetInfo: Fn(&Path) -> Info<Name, Size> + Copy + Send + Sync,
-    JoinPath: Fn(&Path, &Name) -> Path + Copy + Send + Sync,
+    NameIter: IntoIterator,
+    NameIter::IntoIter: Send,
+    NameIter::Item: Send,
+    GetInfo: Fn(&Path) -> Info<NameIter, Size> + Copy + Send + Sync,
+    JoinPath: Fn(&Path, &NameIter::Item) -> Path + Copy + Send + Sync,
     Size: size::Size + Send,
 {
     /// Path to the root.
     pub path: Path,
     /// Name of the root.
-    pub name: Name,
+    pub name: NameIter::Item,
     /// Function to extract necessary information from `path` (`size` and `children`).
     pub get_info: GetInfo,
     /// Function to join parent's `path` with a child's name to make the child's `name`.
@@ -27,17 +29,19 @@ where
     pub max_depth: u64,
 }
 
-impl<Path, Name, Size, GetInfo, JoinPath> From<TreeBuilder<Path, Name, Size, GetInfo, JoinPath>>
-    for DataTree<Name, Size>
+impl<Path, NameIter, Size, GetInfo, JoinPath>
+    From<TreeBuilder<Path, NameIter, Size, GetInfo, JoinPath>> for DataTree<NameIter::Item, Size>
 where
     Path: Send + Sync,
-    Name: Send + Sync,
-    GetInfo: Fn(&Path) -> Info<Name, Size> + Copy + Send + Sync,
-    JoinPath: Fn(&Path, &Name) -> Path + Copy + Send + Sync,
+    NameIter: IntoIterator,
+    NameIter::IntoIter: Send,
+    NameIter::Item: Send,
+    GetInfo: Fn(&Path) -> Info<NameIter, Size> + Copy + Send + Sync,
+    JoinPath: Fn(&Path, &NameIter::Item) -> Path + Copy + Send + Sync,
     Size: size::Size + Send,
 {
     /// Create a [`DataTree`] from a [`TreeBuilder`].
-    fn from(builder: TreeBuilder<Path, Name, Size, GetInfo, JoinPath>) -> Self {
+    fn from(builder: TreeBuilder<Path, NameIter, Size, GetInfo, JoinPath>) -> Self {
         let TreeBuilder {
             path,
             name,
@@ -50,7 +54,8 @@ where
         let max_depth = max_depth.saturating_sub(1);
 
         let children = children
-            .into_par_iter()
+            .into_iter()
+            .par_bridge()
             .map(|name| TreeBuilder {
                 path: join_path(&path, &name),
                 name,

src/tree_builder/info.rs

@@ -1,12 +1,11 @@
 use crate::size;
 use derive_more::From;
-use smart_default::SmartDefault;
 
 /// Information to return from `get_info` of [`super::TreeBuilder`].
-#[derive(Debug, SmartDefault, From)]
-pub struct Info<Name, Size: size::Size> {
+#[derive(Debug, Default, From)]
+pub struct Info<NameIter, Size: size::Size> {
     /// Size associated with given `path`.
     pub size: Size,
     /// Direct descendants of given `path`.
-    pub children: Vec<Name>, // TODO: change this into an iterator
+    pub children: NameIter,
 }