feat(api): obscure container type

Author: KSXGitHub

src/app/sub.rs

@@ -199,10 +199,11 @@ where
         data_tree: &mut DataTree<OsStringDisplay, Size>,
         record: Self::HardlinkRecord,
     ) -> Result<Self::DeduplicationReport, RuntimeError> {
-        use std::path::{Path, PathBuf};
-        let hardlink_info: Box<[(Size, Vec<PathBuf>)]> = record
+        use crate::hardlink::LinkPathList;
+        use std::path::Path;
+        let hardlink_info: Box<[(Size, LinkPathList)]> = record
             .iter()
-            .map(|values| (*values.size(), values.links().to_vec()))
+            .map(|values| (*values.size(), values.links().clone()))
             .collect();
         let hardlink_info: Box<[(Size, Vec<&Path>)]> = hardlink_info
             .iter()

src/hardlink.rs

@@ -0,0 +1,3 @@
+pub mod link_path_list;
+
+pub use link_path_list::LinkPathList;

src/hardlink/link_path_list.rs

@@ -0,0 +1,89 @@
+use pipe_trait::Pipe;
+use std::{iter::FusedIterator, path::PathBuf, slice};
+
+/// List of different hardlinks to the same file.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct LinkPathList(
+    Vec<PathBuf>, // TODO: benchmark against LinkedList<PathBuf>
+);
+
+impl LinkPathList {
+    /// Create a list of a single path.
+    pub(crate) fn single(path: PathBuf) -> Self {
+        LinkPathList(vec![path])
+    }
+
+    /// Add a path to the list.
+    pub(crate) fn add(&mut self, path: PathBuf) {
+        self.0.push(path)
+    }
+
+    /// Get the number of paths inside the list.
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// Check whether the list is empty.
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// Iterate over the paths inside the list.
+    pub fn iter(&self) -> Iter {
+        self.0.iter().pipe(Iter)
+    }
+}
+
+/// [Iterator] over the paths inside a [`LinkPathList`].
+#[derive(Debug, Clone)]
+pub struct Iter<'a>(slice::Iter<'a, PathBuf>);
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = &'a PathBuf;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        self.0.count()
+    }
+
+    #[inline]
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        self.0.nth(n)
+    }
+
+    #[inline]
+    fn last(self) -> Option<Self::Item> {
+        self.0.last()
+    }
+}
+
+impl<'a> DoubleEndedIterator for Iter<'a> {
+    #[inline]
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.0.next_back()
+    }
+
+    #[inline]
+    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
+        self.0.nth_back(n)
+    }
+}
+
+impl<'a> ExactSizeIterator for Iter<'a> {
+    #[inline]
+    fn len(&self) -> usize {
+        self.0.len()
+    }
+}
+
+impl FusedIterator for Iter<'_> {}

src/hook/record_hardlink/storage.rs

@@ -1,17 +1,14 @@
-use crate::size;
+use crate::{hardlink::LinkPathList, 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},
-};
+use std::{fmt::Debug, path::Path};
 
 /// 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>)>>
+    DashMap<u64, (Size, LinkPathList)>, // TODO: benchmark against Mutex<HashMap<u64, (Size, LinkPathList)>>
 );
 
 impl<Size> RecordHardLinkStorage<Size> {
@@ -62,7 +59,7 @@ where
             .and_modify(|(recorded, paths)| {
                 let (detected, recorded) = (size, *recorded);
                 if size == recorded {
-                    paths.push(path.to_path_buf());
+                    paths.add(path.to_path_buf());
                 } else {
                     size_assertion = Err(SizeConflictError {
                         ino,
@@ -71,7 +68,7 @@ where
                     });
                 }
             })
-            .or_insert_with(|| (size, vec![path.to_path_buf()]));
+            .or_insert_with(|| (size, path.to_path_buf().pipe(LinkPathList::single)));
         size_assertion.map_err(AddError::SizeConflict)
     }
 }
@@ -80,13 +77,13 @@ where
 #[derive(derive_more::Debug)]
 #[debug(bound())]
 #[debug("Iter(..)")]
-pub struct Iter<'a, Size>(DashIter<'a, u64, (Size, Vec<PathBuf>)>);
+pub struct Iter<'a, Size>(DashIter<'a, u64, (Size, LinkPathList)>);
 
 /// [Item](Iterator::Item) of [`Iter`].
 #[derive(derive_more::Debug)]
 #[debug(bound())]
 #[debug("IterItem(..)")]
-pub struct IterItem<'a, Size>(RefMulti<'a, u64, (Size, Vec<PathBuf>)>);
+pub struct IterItem<'a, Size>(RefMulti<'a, u64, (Size, LinkPathList)>);
 
 impl<'a, Size> Iterator for Iter<'a, Size> {
     type Item = IterItem<'a, Size>;
@@ -107,7 +104,7 @@ impl<'a, Size> IterItem<'a, Size> {
     }
 
     /// Links of the inode.
-    pub fn links(&self) -> &[PathBuf] {
+    pub fn links(&self) -> &LinkPathList {
         &self.0.value().1
     }
 }

src/lib.rs

@@ -33,6 +33,7 @@ pub mod bytes_format;
 pub mod data_tree;
 pub mod fs_tree_builder;
 pub mod get_size;
+pub mod hardlink;
 pub mod hook;
 pub mod json_data;
 pub mod os_string_display;