Merge pull request #57 from orxfun/crate-converted-into-no_std

crate converted into no_std

Author: orxfun

Cargo.toml

@@ -1,17 +1,17 @@
 [package]
 name = "orx-split-vec"
-version = "3.7.0"
+version = "3.8.0"
 edition = "2021"
 authors = ["orxfun <[email protected]>"]
 description = "An efficient constant access time vector with dynamic capacity and pinned elements."
 license = "MIT"
 repository = "https://github.com/orxfun/orx-split-vec/"
 keywords = ["vec", "array", "split", "fragments", "pinned"]
-categories = ["data-structures", "rust-patterns"]
+categories = ["data-structures", "rust-patterns", "no-std"]
 
 [dependencies]
-orx-pseudo-default = "1.4"
-orx-pinned-vec = "3.7"
+orx-pseudo-default = { version = "1.4", default-features = false }
+orx-pinned-vec = "3.8"
 
 [[bench]]
 name = "serial_access"

src/algorithms/binary_search.rs

@@ -1,5 +1,5 @@
 use crate::Fragment;
-use std::cmp::Ordering;
+use core::cmp::Ordering;
 
 pub fn binary_search_by<T, F>(fragments: &[Fragment<T>], mut compare: F) -> Result<usize, usize>
 where
@@ -46,7 +46,7 @@ mod tests {
     fn bin_search_empty() {
         let cmp = get_compare(42);
 
-        let fragments = vec![];
+        let fragments = alloc::vec![];
         let result = binary_search_by(&fragments, cmp);
         assert_eq!(result, Err(0));
     }
@@ -55,14 +55,14 @@ mod tests {
     fn bin_search_empty_first_fragment() {
         let cmp = get_compare(42);
 
-        let fragments = vec![vec![].into()];
+        let fragments = alloc::vec![alloc::vec![].into()];
         let result = binary_search_by(&fragments, cmp);
         assert_eq!(result, Err(0));
     }
 
     #[test]
     fn bin_search_empty_second_fragment() {
-        let fragments = vec![vec![1, 4, 5].into(), vec![].into()];
+        let fragments = alloc::vec![alloc::vec![1, 4, 5].into(), alloc::vec![].into()];
 
         let result = binary_search_by(&fragments, get_compare(0));
         assert_eq!(result, Err(0));
@@ -85,7 +85,11 @@ mod tests {
 
     #[test]
     fn bin_search_three_fragments() {
-        let fragments = vec![vec![1, 4, 5].into(), vec![7].into(), vec![9, 10].into()];
+        let fragments = alloc::vec![
+            alloc::vec![1, 4, 5].into(),
+            alloc::vec![7].into(),
+            alloc::vec![9, 10].into()
+        ];
 
         let search = |x| binary_search_by(&fragments, get_compare(x));
 
@@ -110,7 +114,7 @@ mod tests {
 
         fn test<G: Growth>(mut vec: SplitVec<usize, G>) {
             let mut rng = ChaCha8Rng::seed_from_u64(8654);
-            let mut ref_vec = vec![];
+            let mut ref_vec = alloc::vec![];
             let mut idx = 0;
             while ref_vec.len() < 1033 {
                 if rng.gen::<f32>() < 0.85 {

src/algorithms/in_place_sort.rs

@@ -1,5 +1,5 @@
 use crate::Fragment;
-use std::cmp::Ordering::{self, *};
+use core::cmp::Ordering::{self, *};
 
 pub fn in_place_sort_by<T, F>(fragments: &mut [Fragment<T>], mut compare: F)
 where
@@ -21,13 +21,13 @@ where
     while r < num_fragments - 1 {
         let row_to_swap = get_row_to_swap(fragments, &mut compare, r, c);
         if let Some(target_row) = row_to_swap {
-            let pa = std::ptr::addr_of_mut!(fragments[r][c]);
-            let pb = std::ptr::addr_of_mut!(fragments[target_row][0]);
+            let pa = core::ptr::addr_of_mut!(fragments[r][c]);
+            let pb = core::ptr::addr_of_mut!(fragments[target_row][0]);
             // SAFETY: `pa` and `pb` have been created from safe mutable references and refer
             // to elements in the slice and therefore are guaranteed to be valid and aligned.
             // Note that accessing the elements behind `a` and `b` is checked and will
             // panic when out of bounds.
-            unsafe { std::ptr::swap(pa, pb) };
+            unsafe { core::ptr::swap(pa, pb) };
 
             let fragment_right = &fragments[target_row][1..];
             let value = &fragments[target_row][0];
@@ -114,11 +114,12 @@ where
 mod tests {
     use super::*;
     use crate::{Doubling, Growth, Linear, Recursive};
+    use alloc::vec::Vec;
     use test_case::test_case;
 
     #[test]
     fn insertion_position() {
-        let fragment: Fragment<u32> = vec![4, 7, 9, 13, 16, 17, 23].into();
+        let fragment: Fragment<u32> = alloc::vec![4, 7, 9, 13, 16, 17, 23].into();
 
         let mut c = |a: &u32, b: &u32| a.cmp(b);
         let mut pos = |val: &u32| find_position_to_insert(&fragment, &mut c, val);
@@ -162,15 +163,15 @@ mod tests {
     fn insertion_position_with_ties() {
         let mut c = |a: &u32, b: &u32| a.cmp(b);
 
-        let fragment: Fragment<u32> = vec![4, 7, 13, 13, 13, 17, 23].into();
+        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);
         assert_eq!(pos(&13), Some(2));
 
-        let fragment: Fragment<u32> = vec![4, 7, 13, 13, 23, 23, 23].into();
+        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);
         assert_eq!(pos(&23), Some(4));
 
-        let fragment: Fragment<u32> = vec![4, 4, 13, 13, 23, 23, 23].into();
+        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);
         assert_eq!(pos(&4), None);
     }
@@ -179,8 +180,11 @@ mod tests {
     fn sort_simple() {
         let mut c = |a: &u32, b: &u32| a.cmp(b);
 
-        let mut fragments: Vec<Fragment<u32>> =
-            vec![vec![2, 4].into(), vec![0, 5, 6].into(), vec![1, 3].into()];
+        let mut fragments: Vec<Fragment<u32>> = alloc::vec![
+            alloc::vec![2, 4].into(),
+            alloc::vec![0, 5, 6].into(),
+            alloc::vec![1, 3].into()
+        ];
 
         in_place_sort_by(&mut fragments, &mut c);
 
@@ -194,7 +198,7 @@ mod tests {
         let mut c = |a: &i32, b: &i32| a.cmp(b);
 
         let num_fragments = 10;
-        let mut fragments: Vec<Fragment<_>> = vec![];
+        let mut fragments: Vec<Fragment<_>> = alloc::vec![];
 
         let mut len = 0;
         for _ in 0..num_fragments {

src/common_traits/clone.rs

@@ -1,4 +1,5 @@
 use crate::{Growth, SplitVec};
+use alloc::vec::Vec;
 use orx_pinned_vec::PinnedVec;
 
 impl<T, G> Clone for SplitVec<T, G>

src/common_traits/debug.rs

@@ -1,14 +1,13 @@
-use orx_pinned_vec::PinnedVec;
-
 use crate::{Growth, SplitVec};
-use std::fmt::Debug;
+use core::fmt::Debug;
+use orx_pinned_vec::PinnedVec;
 
 impl<T, G> Debug for SplitVec<T, G>
 where
     T: Debug,
     G: Growth,
 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         writeln!(
             f,
             "SplitVec {{ len: {}, capacity:{}, data: [",
@@ -25,6 +24,7 @@ where
 #[cfg(test)]
 mod tests {
     use crate::*;
+    use alloc::format;
 
     #[test]
     fn debug() {

src/common_traits/eq.rs

@@ -1,4 +1,5 @@
 use crate::*;
+use alloc::vec::Vec;
 
 impl<T, G, U> PartialEq<U> for SplitVec<T, G>
 where
@@ -81,6 +82,7 @@ pub(crate) fn are_fragments_eq_to_slice<T: PartialEq>(
 mod tests {
     use crate::test_all_growth_types;
     use crate::*;
+    use alloc::vec::Vec;
 
     #[test]
     fn eq() {

src/common_traits/index.rs

@@ -1,5 +1,5 @@
 use crate::{Growth, SplitVec};
-use std::ops::{Index, IndexMut};
+use core::ops::{Index, IndexMut};
 
 impl<T, G> Index<usize> for SplitVec<T, G>
 where
@@ -191,6 +191,7 @@ where
 mod tests {
     use crate::test_all_growth_types;
     use crate::*;
+    use alloc::vec::Vec;
 
     #[test]
     fn index() {

src/common_traits/iterator/into_iter.rs

@@ -1,5 +1,6 @@
 use crate::{Fragment, Growth, SplitVec};
-use std::iter::FusedIterator;
+use alloc::vec::Vec;
+use core::iter::FusedIterator;
 
 impl<T, G: Growth> IntoIterator for SplitVec<T, G> {
     type Item = T;
@@ -14,8 +15,8 @@ impl<T, G: Growth> IntoIterator for SplitVec<T, G> {
 ///
 /// This struct is created by the `into_iter` method on `SplitVec` (provided by the `IntoIterator` trait).
 pub struct IntoIter<T> {
-    outer: std::vec::IntoIter<Fragment<T>>,
-    inner: std::vec::IntoIter<T>,
+    outer: alloc::vec::IntoIter<Fragment<T>>,
+    inner: alloc::vec::IntoIter<T>,
 }
 
 impl<T> IntoIter<T> {
@@ -24,7 +25,7 @@ impl<T> IntoIter<T> {
         let inner = outer
             .next()
             .map(|f| f.data.into_iter())
-            .unwrap_or(vec![].into_iter());
+            .unwrap_or(Vec::new().into_iter());
 
         Self { outer, inner }
     }

src/common_traits/iterator/iter.rs

@@ -1,15 +1,15 @@
 use super::reductions;
 use crate::fragment::fragment_struct::Fragment;
-use std::iter::FusedIterator;
+use core::iter::FusedIterator;
 
 /// Iterator over the `SplitVec`.
 ///
 /// This struct is created by `SplitVec::iter()` method.
 #[derive(Debug)]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct Iter<'a, T> {
-    outer: std::slice::Iter<'a, Fragment<T>>,
-    inner: std::slice::Iter<'a, T>,
+    outer: core::slice::Iter<'a, Fragment<T>>,
+    inner: core::slice::Iter<'a, T>,
 }
 
 impl<'a, T> Iter<'a, T> {

src/common_traits/iterator/iter_mut.rs

@@ -1,14 +1,14 @@
 use crate::fragment::fragment_struct::Fragment;
-use std::iter::FusedIterator;
+use core::iter::FusedIterator;
 
 /// Mutable iterator over the `SplitVec`.
 ///
 /// This struct is created by `SplitVec::iter_mut()` method.
 #[derive(Debug)]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct IterMut<'a, T> {
-    iter_outer: std::slice::IterMut<'a, Fragment<T>>,
-    iter_inner: std::slice::IterMut<'a, T>,
+    iter_outer: core::slice::IterMut<'a, Fragment<T>>,
+    iter_inner: core::slice::IterMut<'a, T>,
 }
 
 impl<'a, T> IterMut<'a, T> {

src/common_traits/iterator/iter_mut_rev.rs

@@ -1,14 +1,14 @@
 use crate::fragment::fragment_struct::Fragment;
-use std::iter::{FusedIterator, Rev};
+use core::iter::{FusedIterator, Rev};
 
 /// Mutable iterator over the `SplitVec`.
 ///
 /// This struct is created by `SplitVec::iter_mut_rev()` method.
 #[derive(Debug)]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct IterMutRev<'a, T> {
-    iter_outer: Rev<std::slice::IterMut<'a, Fragment<T>>>,
-    iter_inner: Rev<std::slice::IterMut<'a, T>>,
+    iter_outer: Rev<core::slice::IterMut<'a, Fragment<T>>>,
+    iter_inner: Rev<core::slice::IterMut<'a, T>>,
 }
 
 impl<'a, T> IterMutRev<'a, T> {

src/common_traits/iterator/iter_rev.rs

@@ -1,14 +1,14 @@
 use crate::fragment::fragment_struct::Fragment;
-use std::iter::{FusedIterator, Rev};
+use core::iter::{FusedIterator, Rev};
 
 /// Iterator over the `SplitVec`.
 ///
 /// This struct is created by `SplitVec::iter_rev()` method.
 #[derive(Debug)]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct IterRev<'a, T> {
-    iter_outer: Rev<std::slice::Iter<'a, Fragment<T>>>,
-    iter_inner: Rev<std::slice::Iter<'a, T>>,
+    iter_outer: Rev<core::slice::Iter<'a, Fragment<T>>>,
+    iter_inner: Rev<core::slice::Iter<'a, T>>,
 }
 
 impl<'a, T> IterRev<'a, T> {

src/common_traits/iterator/reductions.rs

@@ -1,5 +1,5 @@
 use crate::Fragment;
-use std::slice::Iter;
+use core::slice::Iter;
 
 type Outer<'a, T> = Iter<'a, Fragment<T>>;
 type Inner<'a, T> = Iter<'a, T>;

src/common_traits/iterator/tests/into_iter.rs

@@ -1,4 +1,5 @@
 use crate::{test_all_growth_types, Growth, SplitVec};
+use alloc::vec::Vec;
 use orx_pinned_vec::PinnedVec;
 
 #[test]
@@ -48,7 +49,7 @@ fn iter_one_fragment() {
         vec.push(0);
         vec.push(1);
 
-        assert_eq!(vec![0, 1], vec.into_iter().collect::<Vec<_>>());
+        assert_eq!(alloc::vec![0, 1], vec.into_iter().collect::<Vec<_>>());
     }
     test_all_growth_types!(test);
 }