Merge pull request #28 from orxfun/get_ptr_mut-and-useful-From-implementations

`get_ptr_mut` and useful `From` implementations

Author: orxfun

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "orx-split-vec"
-version = "2.3.0"
+version = "2.4.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.2"
+orx-pinned-vec = "2.3"
 
 [[bench]]
 name = "serial_access"

README.md

@@ -76,7 +76,7 @@ The second method `fn get_fragment_and_inner_indices<T>(&self, vec_len: usize, f
 ### D.1. Usage similar to `std::vec::Vec`
 
 ```rust
-use orx_split_vec::prelude::*;
+use orx_split_vec::*;
 
 let mut vec = SplitVec::new();
 
@@ -101,7 +101,7 @@ assert_eq!(&std_vec, &[0, 1, 2, 3]);
 ### D.2. `SplitVec` Specific Operations
 
 ```rust
-use orx_split_vec::prelude::*;
+use orx_split_vec::*;
 
 #[derive(Clone)]
 struct MyCustomGrowth;
@@ -163,7 +163,7 @@ assert_eq!(slice[1], &[4]);
 Unless elements are removed from the vector, the memory location of an element already pushed to the `SplitVec` <ins>never</ins> changes unless explicitly changed.
 
 ```rust
-use orx_split_vec::prelude::*;
+use orx_split_vec::*;
 
 let mut vec = SplitVec::new(); // Doubling growth as the default strategy
 

benches/append.rs

@@ -1,5 +1,5 @@
 use criterion::{black_box, criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion};
-use orx_split_vec::prelude::*;
+use orx_split_vec::*;
 use rand::prelude::*;
 use rand_chacha::ChaCha8Rng;
 

benches/grow.rs

@@ -2,7 +2,7 @@ use criterion::{
     black_box, criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, BenchmarkId,
     Criterion,
 };
-use orx_split_vec::prelude::*;
+use orx_split_vec::*;
 
 fn get_value<const N: usize>(i: usize) -> [u64; N] {
     let modulo = i % 3;

benches/random_access.rs

@@ -2,7 +2,7 @@ use criterion::{
     black_box, criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, BenchmarkId,
     Criterion,
 };
-use orx_split_vec::prelude::*;
+use orx_split_vec::*;
 use rand::prelude::*;
 use rand_chacha::ChaCha8Rng;
 

benches/serial_access.rs

@@ -2,7 +2,7 @@ use criterion::{
     black_box, criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, BenchmarkId,
     Criterion,
 };
-use orx_split_vec::prelude::*;
+use orx_split_vec::*;
 
 fn get_value<const N: usize>(i: usize) -> [u64; N] {
     let modulo = i % 3;

src/common_traits/debug.rs

@@ -17,18 +17,18 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::prelude::*;
+    use crate::*;
 
     #[test]
     fn debug() {
         let mut vec = SplitVec::with_doubling_growth();
-        for i in 0..8 {
+        for i in 0..13 {
             vec.push(i);
         }
 
         let debug_str = format!("{:?}", vec);
         assert_eq!(
-            "SplitVec [\n    [0, 1, 2, 3]\n    [4, 5, 6, 7]\n]\n",
+            "SplitVec [\n    [0, 1, 2, 3]\n    [4, 5, 6, 7, 8, 9, 10, 11]\n    [12]\n]\n",
             debug_str
         );
     }

src/common_traits/eq.rs

@@ -1,4 +1,4 @@
-use crate::{eq::are_fragments_eq_to_slice, Growth, SplitVec};
+use crate::*;
 
 impl<T, G, U> PartialEq<U> for SplitVec<T, G>
 where
@@ -11,10 +11,76 @@ where
     }
 }
 
+impl<T: PartialEq, G> PartialEq<SplitVec<T, G>> for [T]
+where
+    G: Growth,
+{
+    fn eq(&self, other: &SplitVec<T, G>) -> bool {
+        are_fragments_eq_to_slice(&other.fragments, self)
+    }
+}
+
+impl<T: PartialEq, G> PartialEq<SplitVec<T, G>> for Vec<T>
+where
+    G: Growth,
+{
+    fn eq(&self, other: &SplitVec<T, G>) -> bool {
+        are_fragments_eq_to_slice(&other.fragments, self)
+    }
+}
+
+impl<T: PartialEq, G, const N: usize> PartialEq<SplitVec<T, G>> for [T; N]
+where
+    G: Growth,
+{
+    fn eq(&self, other: &SplitVec<T, G>) -> bool {
+        are_fragments_eq_to_slice(&other.fragments, self)
+    }
+}
+
+impl<T: PartialEq, G> PartialEq<SplitVec<T, G>> for SplitVec<T, G>
+where
+    G: Growth,
+{
+    fn eq(&self, other: &SplitVec<T, G>) -> bool {
+        let mut iter1 = self.iter();
+        let mut iter2 = other.iter();
+        loop {
+            match (iter1.next(), iter2.next()) {
+                (Some(x), Some(y)) => {
+                    if x != y {
+                        return false;
+                    }
+                }
+                (None, None) => return true,
+                _ => return false,
+            }
+        }
+    }
+}
+
+impl<T: PartialEq, G: Growth> Eq for SplitVec<T, G> {}
+
+pub(crate) fn are_fragments_eq_to_slice<T: PartialEq>(
+    fragments: &[Fragment<T>],
+    slice: &[T],
+) -> bool {
+    let mut slice_beg = 0;
+    for fragment in fragments {
+        let slice_end = slice_beg + fragment.len();
+        let slice_of_slice = &slice[slice_beg..slice_end];
+        if fragment.data != slice_of_slice {
+            return false;
+        }
+        slice_beg = slice_end;
+    }
+    true
+}
+
 #[cfg(test)]
 mod tests {
-    use crate::prelude::*;
     use crate::test_all_growth_types;
+    use crate::*;
 
     #[test]
     fn eq() {
@@ -24,8 +90,12 @@ mod tests {
             }
 
             let eq_vec: Vec<_> = (0..vec.capacity()).collect();
+            let eq_vec_as_ref: &[usize] = eq_vec.as_ref();
+            assert_eq!(vec, eq_vec_as_ref);
+            assert_eq!(&vec, &eq_vec);
             assert_eq!(vec, eq_vec);
         }
+
         test_all_growth_types!(test);
     }
 }

src/common_traits/index.rs

@@ -16,7 +16,7 @@ where
     /// # Examples
     ///
     /// ```
-    /// use orx_split_vec::prelude::*;
+    /// use orx_split_vec::*;
     ///
     /// let mut vec = SplitVec::with_linear_growth(4);
     ///
@@ -47,7 +47,7 @@ where
     /// # Examples
     ///
     /// ```
-    /// use orx_split_vec::prelude::*;
+    /// use orx_split_vec::*;
     ///
     /// let mut vec = SplitVec::with_linear_growth(2);
     ///
@@ -93,7 +93,7 @@ where
     /// `(i / N, i % N)`.
     ///
     /// ```
-    /// use orx_split_vec::prelude::*;
+    /// use orx_split_vec::*;
     ///
     /// let mut vec = SplitVec::with_linear_growth(2);
     ///
@@ -150,7 +150,7 @@ where
     /// `(i / N, i % N)`.
     ///
     /// ```
-    /// use orx_split_vec::prelude::*;
+    /// use orx_split_vec::*;
     ///
     /// let mut vec = SplitVec::with_linear_growth(2);
     ///
@@ -189,8 +189,8 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::prelude::*;
     use crate::test_all_growth_types;
+    use crate::*;
 
     #[test]
     fn index() {

src/common_traits/iterator/iter.rs

@@ -113,4 +113,22 @@ mod tests {
         }
         test_all_growth_types!(test);
     }
+
+    #[test]
+    fn clone() {
+        fn test<G: Growth>(mut vec: SplitVec<usize, G>) {
+            let n = 564;
+            let stdvec: Vec<_> = (0..n).collect();
+            vec.extend(stdvec);
+
+            let iter1 = vec.iter();
+            let iter2 = iter1.clone();
+
+            for (i, (a, b)) in iter1.zip(iter2).enumerate() {
+                assert_eq!(i, *a);
+                assert_eq!(i, *b);
+            }
+        }
+        test_all_growth_types!(test);
+    }
 }

src/common_traits/iterator/iter_rev.rs

@@ -116,4 +116,22 @@ mod tests {
         }
         test_all_growth_types!(test);
     }
+
+    #[test]
+    fn clone() {
+        fn test<G: Growth>(mut vec: SplitVec<usize, G>) {
+            let n = 564;
+            let stdvec: Vec<_> = (0..n).collect();
+            vec.extend(stdvec);
+
+            let iter1 = vec.iter_rev();
+            let iter2 = iter1.clone();
+
+            for (i, (a, b)) in iter1.zip(iter2).enumerate() {
+                assert_eq!(n - i - 1, *a);
+                assert_eq!(n - i - 1, *b);
+            }
+        }
+        test_all_growth_types!(test);
+    }
 }