feat(api): stop exposing dashmap

Author: KSXGitHub

src/app/sub.rs

@@ -202,7 +202,7 @@ where
         use std::path::{Path, PathBuf};
         let hardlink_info: Box<[(Size, Vec<PathBuf>)]> = record
             .iter()
-            .map(|values| (values.0, values.1.clone()))
+            .map(|values| (*values.size(), values.links().to_vec()))
             .collect();
         let hardlink_info: Box<[(Size, Vec<&Path>)]> = hardlink_info
             .iter()
@@ -218,9 +218,9 @@ where
     ) -> Result<(), RuntimeError> {
         let (inodes, links, size): (usize, usize, Size) = report
             .iter()
-            .filter_map(|ref_multi| {
-                let (size, links) = &*ref_multi;
-                let links = links.len();
+            .filter_map(|values| {
+                let size = values.size();
+                let links = values.links().len();
                 (links > 1).then_some(())?;
                 Some((*size, links))
             })

src/hook.rs

@@ -39,9 +39,8 @@ impl<Size, Reporter> Hook<Size, Reporter> for DoNothing {
 
 // `RecordHardlink` is POSIX-exclusive, because whilst Windows does have `MetadataExt::number_of_links`, it requires Nightly.
 #[cfg(unix)]
-mod record_hardlink;
+pub mod record_hardlink;
 #[cfg(unix)]
 pub use record_hardlink::RecordHardLink;
 #[cfg(unix)]
-#[cfg(feature = "cli")]
-pub(crate) use record_hardlink::RecordHardLinkStorage;
+pub use record_hardlink::RecordHardLinkStorage;

src/hook/record_hardlink.rs

@@ -1,13 +1,13 @@
+pub mod storage;
+
+pub use storage::RecordHardLinkStorage;
+
 use super::{Hook, HookArgument};
 use crate::{
     reporter::{event::EncounterHardlink, Event, Reporter},
     size,
 };
-use dashmap::DashMap;
-use std::{fmt::Debug, os::unix::fs::MetadataExt, path::PathBuf};
-
-/// Map an inode number to its size and detected paths.
-pub type RecordHardLinkStorage<Size> = DashMap<u64, (Size, Vec<PathBuf>)>; // TODO: benchmark against Mutex<HashMap<u64, (Size, Vec<PathBuf>)>>
+use std::{fmt::Debug, os::unix::fs::MetadataExt};
 
 /// A [hook](Hook) that record files with more than 1 links.
 #[derive(Debug, Clone, Copy)]
@@ -52,15 +52,6 @@ where
             links,
         }));
 
-        self.storage
-            .entry(stats.ino())
-            .and_modify(|(expected_size, paths)| {
-                assert_eq!(
-                    size, *expected_size,
-                    "same ino but different sizes: {size:?} vs {expected_size:?}",
-                );
-                paths.push(path.to_path_buf());
-            })
-            .or_insert_with(|| (size, vec![path.to_path_buf()]));
+        self.storage.add(stats.ino(), size, path).unwrap(); // TODO: propagate the error
     }
 }

src/hook/record_hardlink/storage.rs

@@ -0,0 +1,113 @@
+use crate::size;
+use dashmap::{iter::Iter as DashIter, mapref::multiple::RefMulti, DashMap};
+use derive_more::{Display, Error};
+use pipe_trait::Pipe;
+use std::{
+    fmt::Debug,
+    path::{Path, PathBuf},
+};
+
+/// Storage to be used by [`crate::hook::RecordHardLink`].
+#[derive(Debug, Clone)]
+pub struct RecordHardLinkStorage<Size>(
+    /// Map an inode number to its size and detected paths.
+    DashMap<u64, (Size, Vec<PathBuf>)>, // TODO: benchmark against Mutex<HashMap<u64, (Size, Vec<PathBuf>)>>
+);
+
+impl<Size> RecordHardLinkStorage<Size> {
+    /// Create a new record.
+    pub fn new() -> Self {
+        RecordHardLinkStorage(DashMap::new())
+    }
+
+    /// Iterate over the recorded entries.
+    pub fn iter(&self) -> Iter<Size> {
+        self.0.iter().pipe(Iter)
+    }
+}
+
+impl<Size> Default for RecordHardLinkStorage<Size> {
+    fn default() -> Self {
+        RecordHardLinkStorage::new()
+    }
+}
+
+/// Error that occurs when a different size was detected for the same [`ino`](std::os::unix::fs::MetadataExt::ino).
+#[derive(Debug, Display, Error)]
+#[display(bound(Size: Debug))]
+#[display("Size for inode {ino} changed from {recorded:?} to {detected:?}")]
+pub struct SizeConflictError<Size> {
+    pub ino: u64, // TODO: define a newtype of ino.
+    pub recorded: Size,
+    pub detected: Size,
+}
+
+/// Error type of [`RecordHardLinkStorage::add`].
+#[derive(Debug, Display, Error)]
+#[display(bound(Size: Debug))]
+#[non_exhaustive]
+pub enum AddError<Size> {
+    SizeConflict(SizeConflictError<Size>),
+}
+
+impl<Size> RecordHardLinkStorage<Size>
+where
+    Size: size::Size,
+{
+    /// Add an entry to the record.
+    pub(crate) fn add(&self, ino: u64, size: Size, path: &Path) -> Result<(), AddError<Size>> {
+        let mut size_assertion = Ok(());
+        self.0
+            .entry(ino)
+            .and_modify(|(recorded, paths)| {
+                let (detected, recorded) = (size, *recorded);
+                if size == recorded {
+                    paths.push(path.to_path_buf());
+                } else {
+                    size_assertion = Err(SizeConflictError {
+                        ino,
+                        recorded,
+                        detected,
+                    });
+                }
+            })
+            .or_insert_with(|| (size, vec![path.to_path_buf()]));
+        size_assertion.map_err(AddError::SizeConflict)
+    }
+}
+
+/// Iterator over entries in [`RecordHardLinkStorage`].
+#[derive(derive_more::Debug)]
+#[debug(bound())]
+#[debug("Iter(..)")]
+pub struct Iter<'a, Size>(DashIter<'a, u64, (Size, Vec<PathBuf>)>);
+
+/// [Item](Iterator::Item) of [`Iter`].
+#[derive(derive_more::Debug)]
+#[debug(bound())]
+#[debug("IterItem(..)")]
+pub struct IterItem<'a, Size>(RefMulti<'a, u64, (Size, Vec<PathBuf>)>);
+
+impl<'a, Size> Iterator for Iter<'a, Size> {
+    type Item = IterItem<'a, Size>;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next().map(IterItem)
+    }
+}
+
+impl<'a, Size> IterItem<'a, Size> {
+    /// Number of the inode.
+    pub fn ino(&self) -> u64 {
+        *self.0.key()
+    }
+
+    /// Size of the inode.
+    pub fn size(&self) -> &Size {
+        &self.0.value().0
+    }
+
+    /// Links of the inode.
+    pub fn links(&self) -> &[PathBuf] {
+        &self.0.value().1
+    }
+}

src/lib.rs

@@ -28,8 +28,6 @@ pub use clap;
 pub use clap_complete;
 #[cfg(feature = "cli")]
 pub use clap_utilities;
-#[cfg(unix)]
-pub use dashmap;
 
 pub mod bytes_format;
 pub mod data_tree;