Merge pull request #93 from orxfun/handle-zst-in-concurrent-pinned-vec

Handle zst in concurrent pinned vec

Author: orxfun

src/algorithms/tests/binary_search.rs

@@ -1,5 +1,5 @@
 use crate::algorithms::binary_search::binary_search_by;
-use crate::{Growth, SplitVec, test_all_growth_types};
+use crate::{Fragment, Growth, SplitVec, test_all_growth_types};
 use core::cmp::Ordering;
 use orx_pinned_vec::PinnedVec;
 
@@ -20,14 +20,17 @@ fn bin_search_empty() {
 fn bin_search_empty_first_fragment() {
     let cmp = get_compare(42);
 
-    let fragments = alloc::vec![alloc::vec![].into()];
+    let fragments = alloc::vec![Fragment::new_empty(4)];
     let result = binary_search_by(&fragments, cmp);
     assert_eq!(result, Err(0));
 }
 
 #[test]
 fn bin_search_empty_second_fragment() {
-    let fragments = alloc::vec![alloc::vec![1, 4, 5].into(), alloc::vec![].into()];
+    let fragments = alloc::vec![
+        Fragment::new(4, alloc::vec![1, 4, 5]),
+        Fragment::new_empty(4)
+    ];
 
     let result = binary_search_by(&fragments, get_compare(0));
     assert_eq!(result, Err(0));
@@ -51,9 +54,9 @@ fn bin_search_empty_second_fragment() {
 #[test]
 fn bin_search_three_fragments() {
     let fragments = alloc::vec![
-        alloc::vec![1, 4, 5].into(),
-        alloc::vec![7].into(),
-        alloc::vec![9, 10].into()
+        Fragment::new(3, alloc::vec![1, 4, 5]),
+        Fragment::new(1, alloc::vec![7]),
+        Fragment::new(2, alloc::vec![9, 10]),
     ];
 
     let search = |x| binary_search_by(&fragments, get_compare(x));

src/algorithms/tests/in_place_sort.rs

@@ -8,10 +8,11 @@ use test_case::test_case;
 
 #[test]
 fn insertion_position() {
-    let fragment: Fragment<u32> = alloc::vec![4, 7, 9, 13, 16, 17, 23].into();
+    let vec = alloc::vec![4, 7, 9, 13, 16, 17, 23];
+    let fragment = Fragment::new(vec.capacity(), vec);
 
     let mut c = |a: &u32, b: &u32| a.cmp(b);
-    let mut pos = |val: &u32| find_position_to_insert(&fragment, &mut c, val);
+    let mut pos = |val: &u32| find_position_to_insert(fragment.as_slice(), &mut c, val);
 
     assert_eq!(pos(&0), None);
     assert_eq!(pos(&3), None);
@@ -52,16 +53,16 @@ fn insertion_position() {
 fn insertion_position_with_ties() {
     let mut c = |a: &u32, b: &u32| a.cmp(b);
 
-    let fragment: Fragment<u32> = alloc::vec![4, 7, 13, 13, 13, 17, 23].into();
-    let mut pos = |val: &u32| find_position_to_insert(&fragment, &mut c, val);
+    let fragment: Fragment<u32> = Fragment::new(12, alloc::vec![4, 7, 13, 13, 13, 17, 23]);
+    let mut pos = |val: &u32| find_position_to_insert(fragment.as_slice(), &mut c, val);
     assert_eq!(pos(&13), Some(2));
 
-    let fragment: Fragment<u32> = alloc::vec![4, 7, 13, 13, 23, 23, 23].into();
-    let mut pos = |val: &u32| find_position_to_insert(&fragment, &mut c, val);
+    let fragment: Fragment<u32> = Fragment::new(12, alloc::vec![4, 7, 13, 13, 23, 23, 23]);
+    let mut pos = |val: &u32| find_position_to_insert(fragment.as_slice(), &mut c, val);
     assert_eq!(pos(&23), Some(4));
 
-    let fragment: Fragment<u32> = alloc::vec![4, 4, 13, 13, 23, 23, 23].into();
-    let mut pos = |val: &u32| find_position_to_insert(&fragment, &mut c, val);
+    let fragment: Fragment<u32> = Fragment::new(12, alloc::vec![4, 4, 13, 13, 23, 23, 23]);
+    let mut pos = |val: &u32| find_position_to_insert(fragment.as_slice(), &mut c, val);
     assert_eq!(pos(&4), None);
 }
 
@@ -70,9 +71,9 @@ fn sort_simple() {
     let mut c = |a: &u32, b: &u32| a.cmp(b);
 
     let mut fragments: Vec<Fragment<u32>> = alloc::vec![
-        alloc::vec![2, 4].into(),
-        alloc::vec![0, 5, 6].into(),
-        alloc::vec![1, 3].into()
+        Fragment::new(4, alloc::vec![2, 4]),
+        Fragment::new(4, alloc::vec![0, 5, 6]),
+        Fragment::new(4, alloc::vec![1, 3]),
     ];
 
     in_place_sort_by(&mut fragments, &mut c);
@@ -97,7 +98,7 @@ fn sort_growth(growth: impl Growth) {
     for _ in 0..num_fragments {
         let fragment_capacities: Vec<_> = fragments.iter().map(|x| x.capacity()).collect();
         let mut fragment =
-            Fragment::new(growth.new_fragment_capacity_from(fragment_capacities.into_iter()));
+            Fragment::new_empty(growth.new_fragment_capacity_from(fragment_capacities.into_iter()));
         for i in 0..fragment.capacity() {
             let i = len + i;
             let value = match i % 3 {
@@ -121,7 +122,10 @@ fn sort_growth(growth: impl Growth) {
 }
 
 fn assert_is_sorted<T: Ord>(fragments: Vec<Fragment<T>>) {
-    let flattened: Vec<T> = fragments.into_iter().flat_map(|x| Vec::from(x)).collect();
+    let flattened: Vec<T> = fragments
+        .into_iter()
+        .flat_map(Fragment::into_inner)
+        .collect();
 
     if flattened.is_empty() {
         return;

src/common_traits/clone.rs

@@ -9,13 +9,9 @@ where
 {
     fn clone(&self) -> Self {
         let mut fragments = Vec::with_capacity(self.fragments.capacity());
-
         for fragment in &self.fragments {
-            let mut vec = Vec::with_capacity(fragment.capacity());
-            vec.extend_from_slice(fragment);
-            fragments.push(vec.into());
+            fragments.push(fragment.clone());
         }
-
         Self::from_raw_parts(self.len(), fragments, self.growth().clone())
     }
 }

src/common_traits/eq.rs

@@ -70,7 +70,7 @@ pub(crate) fn are_fragments_eq_to_slice<T: PartialEq>(
     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 {
+        if fragment.as_slice() != slice_of_slice {
             return false;
         }
         slice_beg = slice_end;

src/common_traits/iterator/into_iter.rs

@@ -24,7 +24,7 @@ impl<T> IntoIter<T> {
         let mut outer = fragments.into_iter();
         let inner = outer
             .next()
-            .map(|f| f.data.into_iter())
+            .map(|f| f.into_iter())
             .unwrap_or(Vec::new().into_iter());
 
         Self { outer, inner }
@@ -33,7 +33,7 @@ impl<T> IntoIter<T> {
     fn next_fragment(&mut self) -> Option<T> {
         match self.outer.next() {
             Some(f) => {
-                self.inner = f.data.into_iter();
+                self.inner = f.into_iter();
                 self.next()
             }
             None => None,

src/common_traits/iterator/iter_ptr.rs

@@ -79,7 +79,7 @@ mod tests {
 
     #[test]
     fn ptr_one_empty_fragment() {
-        let fragment: Fragment<String> = Vec::with_capacity(2).into();
+        let fragment = Fragment::new_empty(2);
         let mut fragments: Vec<Fragment<String>> = Vec::with_capacity(4);
         fragments.push(fragment);
 
@@ -91,7 +91,7 @@ mod tests {
 
     #[test]
     fn ptr_one_non_empty_fragment() {
-        let mut fragment: Fragment<String> = Vec::with_capacity(3).into();
+        let mut fragment = Fragment::new_empty(3);
         fragment.push(0.to_string());
         fragment.push(1.to_string());
 
@@ -111,23 +111,23 @@ mod tests {
 
         let prior = 0;
         let n = 4;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..n {
             fragment.push((prior + i).to_string());
         }
         fragments.push(fragment);
 
         let prior = prior + n;
         let n = 8;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..n {
             fragment.push((prior + i).to_string());
         }
         fragments.push(fragment);
 
         let prior = prior + n;
         let n = 16;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..n {
             fragment.push((prior + i).to_string());
         }
@@ -154,23 +154,23 @@ mod tests {
 
         let prior = 0;
         let n = 4;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..n {
             fragment.push((prior + i).to_string());
         }
         fragments.push(fragment);
 
         let prior = prior + n;
         let n = 8;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..n {
             fragment.push((prior + i).to_string());
         }
         fragments.push(fragment);
 
         let prior = prior + n;
         let n = 16;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..(n / 2) {
             fragment.push((prior + i).to_string());
         }
@@ -197,23 +197,23 @@ mod tests {
 
         let prior = 0;
         let n = 4;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..n {
             fragment.push((prior + i).to_string());
         }
         fragments.push(fragment);
 
         let prior = prior + n;
         let n = 8;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..n {
             fragment.push((prior + i).to_string());
         }
         fragments.push(fragment);
 
         let prior = prior + n;
         let n = 16;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..(n / 2) {
             fragment.push((prior + i).to_string());
         }

src/common_traits/iterator/iter_ptr_bwd.rs

@@ -1,7 +1,5 @@
-use crate::{
-    Fragment,
-    pointers::{PtrBackward, Ptrs},
-};
+use crate::Fragment;
+use crate::pointers::{PtrBackward, Ptrs};
 use core::iter::FusedIterator;
 
 #[derive(Copy)]
@@ -79,7 +77,7 @@ mod tests {
 
     #[test]
     fn ptr_bwd_one_empty_fragment() {
-        let fragment: Fragment<String> = Vec::with_capacity(2).into();
+        let fragment = Fragment::new_empty(2);
         let mut fragments: Vec<Fragment<String>> = Vec::with_capacity(4);
         fragments.push(fragment);
 
@@ -91,7 +89,7 @@ mod tests {
 
     #[test]
     fn ptr_bwd_one_non_empty_fragment() {
-        let mut fragment: Fragment<String> = Vec::with_capacity(3).into();
+        let mut fragment = Fragment::new_empty(3);
         fragment.push(0.to_string());
         fragment.push(1.to_string());
 
@@ -111,23 +109,23 @@ mod tests {
 
         let prior = 0;
         let n = 4;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..n {
             fragment.push((prior + i).to_string());
         }
         fragments.push(fragment);
 
         let prior = prior + n;
         let n = 8;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..n {
             fragment.push((prior + i).to_string());
         }
         fragments.push(fragment);
 
         let prior = prior + n;
         let n = 16;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..n {
             fragment.push((prior + i).to_string());
         }
@@ -154,23 +152,23 @@ mod tests {
 
         let prior = 0;
         let n = 4;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..n {
             fragment.push((prior + i).to_string());
         }
         fragments.push(fragment);
 
         let prior = prior + n;
         let n = 8;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..n {
             fragment.push((prior + i).to_string());
         }
         fragments.push(fragment);
 
         let prior = prior + n;
         let n = 16;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..(n / 2) {
             fragment.push((prior + i).to_string());
         }
@@ -197,23 +195,23 @@ mod tests {
 
         let prior = 0;
         let n = 4;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..n {
             fragment.push((prior + i).to_string());
         }
         fragments.push(fragment);
 
         let prior = prior + n;
         let n = 8;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..n {
             fragment.push((prior + i).to_string());
         }
         fragments.push(fragment);
 
         let prior = prior + n;
         let n = 16;
-        let mut fragment: Fragment<String> = Vec::with_capacity(n).into();
+        let mut fragment = Fragment::new_empty(n);
         for i in 0..(n / 2) {
             fragment.push((prior + i).to_string());
         }

src/concurrent_iter/con_iter_owned.rs

@@ -1,9 +1,6 @@
 use crate::{ParGrowth, SplitVec};
-use alloc::vec::Vec;
-use orx_concurrent_iter::{
-    IntoConcurrentIter,
-    implementations::jagged_arrays::{ConIterJaggedOwned, RawJagged, RawVec},
-};
+use orx_concurrent_iter::IntoConcurrentIter;
+use orx_concurrent_iter::implementations::jagged_arrays::{ConIterJaggedOwned, RawJagged, RawVec};
 
 impl<T, G> IntoConcurrentIter for SplitVec<T, G>
 where
@@ -18,7 +15,7 @@ where
         let arrays = self
             .fragments
             .into_iter()
-            .map(|f| RawVec::from(Vec::from(f)))
+            .map(|f| RawVec::from(f.into_inner()))
             .collect();
         let jagged = RawJagged::new(arrays, self.growth, Some(self.len));
         jagged.into_con_iter()