feat: report the number of unrecorded links (wip)

Author: KSXGitHub

src/hardlink/aware.rs

@@ -83,7 +83,7 @@ where
 
         let ino = InodeNumber::get(stats);
         self.record
-            .add(ino, size, path)
+            .add(ino, size, links, path)
             .map_err(ReportHardlinksError::AddToRecord)
     }
 }
@@ -102,7 +102,7 @@ where
         let record: Self::Report = self.into();
         let hardlink_info: Box<[(Size, LinkPathList)]> = record
             .iter()
-            .map(|values| (*values.size(), values.links().clone()))
+            .map(|values| (*values.size(), values.paths().clone()))
             .collect();
         let hardlink_info: Box<[(Size, Vec<&Path>)]> = hardlink_info
             .iter()

src/hardlink/hardlink_list.rs

@@ -16,15 +16,26 @@ use pipe_trait::Pipe;
 use smart_default::SmartDefault;
 use std::{fmt::Debug, path::Path};
 
+/// Map value in [`HardlinkList`].
+#[derive(Debug, Clone)]
+struct Value<Size> {
+    /// The size of the file.
+    size: Size,
+    /// Total number of links of the file, both listed (in [`Self::paths`]) and unlisted.
+    links: u64,
+    /// Paths to the detected links of the file.
+    paths: LinkPathList,
+}
+
 /// Storage to be used by [`crate::hardlink::RecordHardlinks`].
 ///
 /// **Serialization and deserialization:** _(feature: `json`)_ `HardlinkList` does not implement
 /// `Serialize` and `Deserialize` traits directly, instead, it can be converted into/from a
 /// [`Reflection`] which implements these traits.
 #[derive(Debug, SmartDefault, Clone)]
 pub struct HardlinkList<Size>(
-    /// Map an inode number to its size and detected paths.
-    DashMap<InodeNumber, (Size, LinkPathList)>, // TODO: benchmark against Mutex<HashMap<InodeNumber, (Size, LinkPathList)>>
+    /// Map an inode number to its size, number of links, and detected paths.
+    DashMap<InodeNumber, Value<Size>>, // TODO: benchmark against Mutex<HashMap<InodeNumber, Value<Size>>>
 );
 
 impl<Size> HardlinkList<Size> {
@@ -76,24 +87,27 @@ where
         &self,
         ino: InodeNumber,
         size: Size,
+        links: u64,
         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.add(path.to_path_buf());
+            .and_modify(|recorded| {
+                if size == recorded.size {
+                    recorded.paths.add(path.to_path_buf());
                 } else {
                     size_assertion = Err(SizeConflictError {
                         ino,
-                        recorded,
-                        detected,
+                        recorded: recorded.size,
+                        detected: size,
                     });
                 }
             })
-            .or_insert_with(|| (size, path.to_path_buf().pipe(LinkPathList::single)));
+            .or_insert_with(|| {
+                let paths = path.to_path_buf().pipe(LinkPathList::single);
+                Value { size, links, paths }
+            });
         size_assertion.map_err(AddError::SizeConflict)
     }
 }

src/hardlink/hardlink_list/iter.rs

@@ -1,4 +1,4 @@
-use super::HardlinkList;
+use super::{HardlinkList, Value};
 use crate::{hardlink::LinkPathList, inode::InodeNumber};
 use dashmap::{iter::Iter as DashIter, mapref::multiple::RefMulti};
 use pipe_trait::Pipe;
@@ -7,7 +7,7 @@ use pipe_trait::Pipe;
 #[derive(derive_more::Debug)]
 #[debug(bound())]
 #[debug("Iter(..)")]
-pub struct Iter<'a, Size>(DashIter<'a, InodeNumber, (Size, LinkPathList)>);
+pub struct Iter<'a, Size>(DashIter<'a, InodeNumber, Value<Size>>);
 
 impl<Size> HardlinkList<Size> {
     /// Iterate over the recorded entries.
@@ -20,7 +20,7 @@ impl<Size> HardlinkList<Size> {
 #[derive(derive_more::Debug)]
 #[debug(bound())]
 #[debug("Item(..)")]
-pub struct Item<'a, Size>(RefMulti<'a, InodeNumber, (Size, LinkPathList)>);
+pub struct Item<'a, Size>(RefMulti<'a, InodeNumber, Value<Size>>);
 
 impl<'a, Size> Iterator for Iter<'a, Size> {
     type Item = Item<'a, Size>;
@@ -30,18 +30,23 @@ impl<'a, Size> Iterator for Iter<'a, Size> {
 }
 
 impl<'a, Size> Item<'a, Size> {
-    /// Number of the inode.
+    /// The inode number of the file.
     pub fn ino(&self) -> InodeNumber {
         *self.0.key()
     }
 
-    /// Size of the inode.
+    /// Size of the file.
     pub fn size(&self) -> &Size {
-        &self.0.value().0
+        &self.0.value().size
     }
 
-    /// Links of the inode.
-    pub fn links(&self) -> &LinkPathList {
-        &self.0.value().1
+    /// Total number of links of the file, both listed (in [`Self::paths`]) and unlisted.
+    pub fn links(&self) -> u64 {
+        self.0.value().links
+    }
+
+    /// Paths to the detected links of the file.
+    pub fn paths(&self) -> &LinkPathList {
+        &self.0.value().paths
     }
 }

src/hardlink/hardlink_list/reflection.rs

@@ -1,8 +1,5 @@
-use super::HardlinkList;
-use crate::{
-    hardlink::{LinkPathList, LinkPathListReflection},
-    inode::InodeNumber,
-};
+use super::{HardlinkList, Value};
+use crate::{hardlink::LinkPathListReflection, inode::InodeNumber};
 use dashmap::DashMap;
 use derive_more::{Display, Error, Into, IntoIterator};
 use pipe_trait::Pipe;
@@ -44,16 +41,38 @@ impl<Size> Reflection<Size> {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "json", derive(Deserialize, Serialize))]
 pub struct ReflectionEntry<Size> {
+    /// The inode number of the file.
     pub ino: InodeNumber,
+    /// Size of the file.
     pub size: Size,
-    pub links: LinkPathListReflection,
+    /// Total number of links of the file, both listed (in [`Self::paths`]) and unlisted.
+    pub links: u64,
+    /// Paths to the detected links of the file.
+    pub paths: LinkPathListReflection,
 }
 
 impl<Size> ReflectionEntry<Size> {
-    /// Create a new value.
-    fn new(ino: InodeNumber, size: Size, links: LinkPathList) -> Self {
-        let links = links.into();
-        ReflectionEntry { ino, size, links }
+    /// Create a new entry.
+    fn new(ino: InodeNumber, Value { size, links, paths }: Value<Size>) -> Self {
+        let paths = paths.into();
+        ReflectionEntry {
+            ino,
+            size,
+            links,
+            paths,
+        }
+    }
+
+    /// Dissolve [`ReflectionEntry`] into a pair of [`InodeNumber`] and [`Value`].
+    fn dissolve(self) -> (InodeNumber, Value<Size>) {
+        let ReflectionEntry {
+            ino,
+            size,
+            links,
+            paths,
+        } = self;
+        let paths = paths.into();
+        (ino, Value { size, links, paths })
     }
 }
 
@@ -68,7 +87,7 @@ impl<Size> From<Vec<ReflectionEntry<Size>>> for Reflection<Size> {
 impl<Size> From<HardlinkList<Size>> for Reflection<Size> {
     fn from(HardlinkList(list): HardlinkList<Size>) -> Self {
         list.into_iter()
-            .map(|(ino, (size, links))| ReflectionEntry::new(ino, size, links))
+            .map(|(ino, value)| ReflectionEntry::new(ino, value))
             .collect::<Vec<_>>()
             .pipe(Reflection::from)
     }
@@ -89,9 +108,9 @@ impl<Size> TryFrom<Reflection<Size>> for HardlinkList<Size> {
     fn try_from(Reflection(entries): Reflection<Size>) -> Result<Self, Self::Error> {
         let map = DashMap::with_capacity(entries.len());
 
-        for ReflectionEntry { ino, size, links } in entries {
-            let links = links.into();
-            if map.insert(ino, (size, links)).is_some() {
+        for entry in entries {
+            let (ino, value) = entry.dissolve();
+            if map.insert(ino, value).is_some() {
                 return ino.pipe(ConversionError::DuplicatedInode).pipe(Err);
             }
         }

src/hardlink/hardlink_list/summary.rs

@@ -146,7 +146,7 @@ impl<Size: Copy> From<ReflectionEntry<Size>> for SingleInodeSummary<Size> {
 impl<'r, Size: Copy> From<&'r ReflectionEntry<Size>> for SingleInodeSummary<Size> {
     fn from(reflection: &'r ReflectionEntry<Size>) -> Self {
         SingleInodeSummary {
-            links: reflection.links.len(),
+            links: reflection.paths.len(),
             size: reflection.size,
         }
     }
@@ -161,7 +161,7 @@ impl<'a, Size: Copy> From<IterItem<'a, Size>> for SingleInodeSummary<Size> {
 impl<'r, 'a, Size: Copy> From<&'r IterItem<'a, Size>> for SingleInodeSummary<Size> {
     fn from(value: &'r IterItem<'a, Size>) -> Self {
         SingleInodeSummary {
-            links: value.links().len(),
+            links: value.paths().len(),
             size: *value.size(),
         }
     }