feat!: relax Reflection's validation requirements

BEFORE:
A `Reflection` node is valid only if the *sum* of all its children sizes
is less than or equal to the size of the node.

AFTER:
A `Reflection` node is valid only if there's no child whose size is greater
than the size of the node.

BREAKING:
`data_tree::reflection::ConversionError::ExcessiveChildren` now has a
different set of fields.

Author: KSXGitHub

src/data_tree/reflection.rs

@@ -44,16 +44,14 @@ pub struct Reflection<Name, Size: size::Size> {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum ConversionError<Name, Size: size::Size> {
-    /// When a node's size is less than the sum of its children.
+    /// When a node's size is less than one of its children.
     ExcessiveChildren {
         /// Path from root to the node.
         path: VecDeque<Name>,
         /// Size hold by the node.
         size: Size,
-        /// Children of the node.
-        children: Vec<Reflection<Name, Size>>,
-        /// Sum of size hold by children of the node.
-        children_sum: Size,
+        /// The child whose size was greater than that of the node.
+        child: Reflection<Name, Size>,
     },
 }
 
@@ -65,19 +63,16 @@ where
     fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error> {
         use ConversionError::*;
         match self {
-            ExcessiveChildren {
-                path,
-                size,
-                children_sum,
-                ..
-            } => {
+            ExcessiveChildren { path, size, child } => {
                 let path = path
                     .iter()
                     .map(PathBuf::from)
                     .fold(PathBuf::new(), |acc, x| acc.join(x));
                 write!(
                     formatter,
-                    "ExcessiveChildren: {path:?}: {size:?} is less than {children_sum:?}",
+                    "ExcessiveChildren: {path:?} ({size:?}) is less than a child named {child_name:?} ({child_size:?})",
+                    child_name = child.name,
+                    child_size = child.size,
                 )
             }
         }

src/data_tree/reflection/par_methods.rs

@@ -15,14 +15,15 @@ where
             size,
             children,
         } = self;
-        let children_sum = children.iter().map(|child| child.size).sum();
-        if size < children_sum {
-            return Err(ConversionError::ExcessiveChildren {
-                path: once(name).collect(),
-                size,
-                children,
-                children_sum,
-            });
+        let excess_child = children
+            .iter()
+            .enumerate()
+            .find(|(_, child)| child.size > size);
+        if let Some((index, _)) = excess_child {
+            let path = once(name).collect();
+            let mut children = children;
+            let child = children.swap_remove(index); // this still does the unnecessary work of swapping the elements, how to skip it?
+            return Err(ConversionError::ExcessiveChildren { path, size, child });
         }
         let children: Result<Vec<_>, _> = children
             .into_par_iter()
@@ -33,16 +34,10 @@ where
             Err(ConversionError::ExcessiveChildren {
                 mut path,
                 size,
-                children,
-                children_sum,
+                child,
             }) => {
                 path.push_front(name);
-                return Err(ConversionError::ExcessiveChildren {
-                    path,
-                    size,
-                    children,
-                    children_sum,
-                });
+                return Err(ConversionError::ExcessiveChildren { path, size, child });
             }
         };
         Ok(DataTree {

tests/data_tree_reflection.rs

@@ -121,23 +121,11 @@ fn invalid_conversion_excessive_children() {
     let expected = ConversionError::ExcessiveChildren {
         path: vec!["root", "b", "0"].into_iter().collect(),
         size: Bytes::new(321),
-        children: vec![
-            Reflection {
-                name: "abc",
-                size: Bytes::new(123),
-                children: vec![Reflection {
-                    name: "xyz",
-                    size: Bytes::new(4321),
-                    children: Vec::new(),
-                }],
-            },
-            Reflection {
-                name: "def",
-                size: Bytes::new(456),
-                children: Vec::new(),
-            },
-        ],
-        children_sum: Bytes::new(123 + 456),
+        child: Reflection {
+            name: "def",
+            size: Bytes::new(456),
+            children: Vec::new(),
+        },
     };
     assert_eq!(actual, expected);
 }
@@ -148,7 +136,7 @@ fn display_excessive_children() {
         .par_try_into_tree()
         .expect_err("create error")
         .to_string();
-    let expected = r#"ExcessiveChildren: "root/b/0": Bytes(321) is less than Bytes(579)"#;
+    let expected = r#"ExcessiveChildren: "root/b/0" (Bytes(321)) is less than a child named "def" (Bytes(456))"#;
     assert_eq!(actual, expected);
 }