Merge pull request #29 from orxfun/SplitVec-is-extended-by-try_grow

SplitVec is extended by try_grow

Author: orxfun

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "orx-split-vec"
-version = "2.4.0"
+version = "2.5.0"
 edition = "2021"
 authors = ["orxfun <[email protected]>"]
 description = "An efficient constant access time vector with dynamic capacity and pinned elements."
@@ -10,7 +10,7 @@ keywords = ["vec", "array", "split", "fragments", "pinned"]
 categories = ["data-structures", "rust-patterns"]
 
 [dependencies]
-orx-pinned-vec = "2.3"
+orx-pinned-vec = "2.4"
 
 [[bench]]
 name = "serial_access"

src/common_traits/debug.rs

@@ -1,3 +1,5 @@
+use orx_pinned_vec::PinnedVec;
+
 use crate::{Growth, SplitVec};
 use std::fmt::Debug;
 
@@ -7,11 +9,16 @@ where
     G: Growth,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "SplitVec [")?;
+        writeln!(
+            f,
+            "SplitVec {{ len: {}, capacity:{}, data: [",
+            self.len(),
+            self.capacity()
+        )?;
         for frag in &self.fragments {
             writeln!(f, "    {:?}", frag)?;
         }
-        writeln!(f, "]")
+        writeln!(f, "] }}")
     }
 }
 
@@ -28,7 +35,7 @@ mod tests {
 
         let debug_str = format!("{:?}", vec);
         assert_eq!(
-            "SplitVec [\n    [0, 1, 2, 3]\n    [4, 5, 6, 7, 8, 9, 10, 11]\n    [12]\n]\n",
+            "SplitVec { len: 13, capacity:28, data: [\n    [0, 1, 2, 3]\n    [4, 5, 6, 7, 8, 9, 10, 11]\n    [12]\n] }\n",
             debug_str
         );
     }

src/common_traits/iterator/from_iter.rs

@@ -16,23 +16,20 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::{Doubling, Linear, SplitVec};
+    use crate::{Doubling, Recursive, SplitVec};
 
     #[test]
     fn collect() {
         let vec = SplitVec::<_, Doubling>::from_iter([0, 1, 2, 3, 4, 5]);
         assert_eq!(&vec, &[0, 1, 2, 3, 4, 5]);
 
-        let vec = SplitVec::<_, Linear>::from_iter([0, 1, 2, 3, 4, 5]);
-        assert_eq!(&vec, &[0, 1, 2, 3, 4, 5]);
-
         let vec = SplitVec::<_>::from_iter([0, 1, 2, 3, 4, 5]);
         assert_eq!(&vec, &[0, 1, 2, 3, 4, 5]);
 
         let vec: SplitVec<_, Doubling> = (0..6).collect();
         assert_eq!(&vec, &[0, 1, 2, 3, 4, 5]);
 
-        let vec: SplitVec<_, Linear> = (0..6).collect();
+        let vec: SplitVec<_, Recursive> = (0..6).collect();
         assert_eq!(&vec, &[0, 1, 2, 3, 4, 5]);
 
         let vec: SplitVec<_> = (0..6).collect();
@@ -44,7 +41,7 @@ mod tests {
         let vec: SplitVec<_, Doubling> = (0..6).filter(|x| x % 2 == 0).collect();
         assert_eq!(&vec, &[0, 2, 4]);
 
-        let vec: SplitVec<_, Linear> = (0..6).filter(|x| x % 2 == 0).collect();
+        let vec: SplitVec<_, Recursive> = (0..6).filter(|x| x % 2 == 0).collect();
         assert_eq!(&vec, &[0, 2, 4]);
     }
 }

src/fragment/fragment_struct.rs

@@ -8,23 +8,27 @@
 pub struct Fragment<T> {
     pub(crate) data: Vec<T>,
 }
+
 impl<T> Fragment<T> {
     /// Creates a new fragment with the given `capacity` and pushes already the `first_value`.
     pub fn new_with_first_value(capacity: usize, first_value: T) -> Self {
         let mut data = Vec::with_capacity(capacity);
         data.push(first_value);
         Self { data }
     }
+
     /// Creates a new fragment with the given `capacity`.
     pub fn new(capacity: usize) -> Self {
         Self {
             data: Vec::with_capacity(capacity),
         }
     }
+
     /// Returns whether the fragment has room to push a new item or not.
     pub fn has_capacity_for_one(&self) -> bool {
         self.data.len() < self.data.capacity()
     }
+
     /// Returns the available capacity in the fragment.
     pub fn room(&self) -> usize {
         self.data.capacity() - self.data.len()

src/growth/linear/linear_growth.rs

@@ -36,7 +36,7 @@ use crate::{Fragment, SplitVec};
 /// assert_eq!(Some(16), vec.fragments().last().map(|f| f.capacity()));
 /// assert_eq!(Some(1), vec.fragments().last().map(|f| f.len()));
 /// ```
-#[derive(Debug, Default, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Linear {
     constant_fragment_capacity_exponent: usize,
     constant_fragment_capacity: usize,

src/pinned_vec.rs

@@ -1,6 +1,6 @@
 use crate::{Growth, SplitVec};
 use orx_pinned_vec::utils::slice;
-use orx_pinned_vec::PinnedVec;
+use orx_pinned_vec::{PinnedVec, PinnedVecGrowthError};
 
 impl<T, G> PinnedVec<T> for SplitVec<T, G>
 where
@@ -552,16 +552,29 @@ where
         for fragment in &mut self.fragments {
             let capacity = fragment.capacity();
             if remaining <= capacity {
-                unsafe { fragment.set_len(remaining) };
+                if fragment.len() != remaining {
+                    unsafe { fragment.set_len(remaining) };
+                }
             } else {
-                unsafe { fragment.set_len(capacity) };
+                if fragment.len() != capacity {
+                    unsafe { fragment.set_len(capacity) };
+                }
                 remaining -= capacity;
             }
         }
 
         debug_assert_eq!(new_len, self.len());
         debug_assert_eq!(new_len, self.fragments.iter().map(|x| x.len()).sum());
     }
+
+    fn try_grow(&mut self) -> Result<usize, PinnedVecGrowthError> {
+        if self.len() < self.capacity() {
+            Err(PinnedVecGrowthError::CanOnlyGrowWhenVecIsAtCapacity)
+        } else {
+            self.add_fragment();
+            Ok(self.capacity())
+        }
+    }
 }
 
 #[cfg(test)]
@@ -910,4 +923,36 @@ mod tests {
             assert!(unsafe { vec.get_ptr_mut(i) }.is_none());
         }
     }
+
+    #[test]
+    fn try_grow() {
+        fn test<G: Growth>(mut vec: SplitVec<usize, G>) {
+            fn grow_one_fragment<G: Growth>(vec: &mut SplitVec<usize, G>) {
+                let old_len = vec.len();
+                let old_capacity = vec.capacity();
+                assert!(old_len < old_capacity);
+
+                for i in old_len..old_capacity {
+                    assert_eq!(
+                        Err(PinnedVecGrowthError::CanOnlyGrowWhenVecIsAtCapacity),
+                        vec.try_grow()
+                    );
+                    vec.push(i);
+                }
+                assert_eq!(vec.capacity(), old_capacity);
+
+                let result = vec.try_grow();
+                assert!(result.is_ok());
+                let new_capacity = result.expect("is-ok");
+                assert!(new_capacity > old_capacity);
+            }
+
+            for _ in 0..5 {
+                grow_one_fragment(&mut vec);
+            }
+
+            assert_eq!(5 + 1, vec.fragments().len());
+        }
+        test_all_growth_types!(test);
+    }
 }