Merge pull request #38 from orxfun/Use-of-Collection-constrained-PinnedVecs

Use of Collection constrained PinnedVecs

Author: orxfun

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "orx-linked-list"
-version = "3.3.0"
+version = "3.4.0"
 edition = "2021"
 authors = ["orxfun <[email protected]>"]
 description = "A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations."
@@ -11,10 +11,11 @@ categories = ["data-structures", "rust-patterns", "no-std"]
 
 [dependencies]
 orx-pseudo-default = { version = "1.4", default-features = false }
-orx-pinned-vec = "3.11"
-orx-split-vec = "3.11"
-orx-fixed-vec = "3.11"
-orx-selfref-col = "2.3"
+orx-pinned-vec = "3.12"
+orx-fixed-vec = "3.12"
+orx-split-vec = "3.12"
+orx-selfref-col = "2.5"
+orx-iterable = { version = "1.1.1", default-features = false }
 
 [dev-dependencies]
 clap = { version = "4.5.27", features = ["derive"] }
@@ -24,7 +25,7 @@ rand_chacha = "0.3.1"
 test-case = "3.3.1"
 
 [features]
-default = ["validation"]
+default = []
 validation = []
 
 [[bench]]

src/list/common_traits/index.rs

@@ -2,9 +2,9 @@ use crate::{
     type_aliases::OOB, variant::Doubly, DoublyEnds, DoublyEndsMut, DoublyIdx, List, ListSlice,
     ListSliceMut, Singly, SinglyEnds, SinglyEndsMut, SinglyIdx,
 };
+use core::ops::{Index, IndexMut};
 use orx_pinned_vec::PinnedVec;
 use orx_selfref_col::{MemoryPolicy, Node};
-use std::ops::{Index, IndexMut};
 
 // doubly
 

src/list/mutate.rs

@@ -1,6 +1,6 @@
 use super::List;
 use crate::variant::ListVariant;
-use orx_pinned_vec::PinnedVec;
+use orx_iterable::CollectionMut;
 use orx_selfref_col::MemoryPolicy;
 
 impl<V, M> List<V, M>

tests/append.rs

@@ -19,6 +19,7 @@ fn append_front_doubly<M: MemoryPolicy<Doubly<char>>>(mut list: List<Doubly<char
     other.push_back('j');
 
     list.append_front(other);
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals(['f', 'g', 'h', 'i', 'j', 'a', 'b', 'c', 'd', 'e']));
 
@@ -44,6 +45,7 @@ fn append_back_doubly<M: MemoryPolicy<Doubly<char>>>(mut list: List<Doubly<char>
     other.push_back('j');
 
     list.append_back(other);
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']));
 

tests/clone.rs

@@ -8,6 +8,7 @@ fn clone_singly() {
     let list = singly::new_singly(&mut doubly::rng(), 40, 50);
     let clone = list.clone();
 
+    #[cfg(feature = "validation")]
     clone.validate();
 
     assert!(list.eq_to_iter_refs(clone.iter()));
@@ -18,6 +19,7 @@ fn clone_doubly() {
     let list = doubly::new_doubly(&mut doubly::rng(), 40, 50);
     let clone = list.clone();
 
+    #[cfg(feature = "validation")]
     clone.validate();
 
     assert!(list.eq_to_iter_refs(clone.iter()));

tests/from_iter.rs

@@ -5,6 +5,7 @@ use test_case::test_matrix;
 fn from_iter_singly(len: usize) {
     let iter = (0..len).map(|i| i.to_string());
     let list: SinglyList<_> = iter.collect();
+    #[cfg(feature = "validation")]
     list.validate();
 
     match len {
@@ -27,6 +28,7 @@ fn from_iter_singly(len: usize) {
 fn from_iter_doubly(len: usize) {
     let iter = (0..len).map(|i| i.to_string());
     let list: DoublyList<_> = iter.collect();
+    #[cfg(feature = "validation")]
     list.validate();
 
     match len {

tests/insert.rs

@@ -41,6 +41,7 @@ fn insert_doubly<M: MemoryPolicy<Doubly<char>>>(
         false => list.try_insert_prev_to(&indices[idx], 'f'),
     }
     .unwrap();
+    #[cfg(feature = "validation")]
     list.validate();
 
     assert!(list.eq_to_iter_vals(vec.iter().copied()));
@@ -60,6 +61,7 @@ fn insert_doubly_oob(idx: usize, next_to: bool) {
 
     let mut vec = vec!['a', 'b', 'c', 'd', 'e'];
     vec.remove(idx);
+    #[cfg(feature = "validation")]
     list.validate();
 
     let idx = match idx {
@@ -70,6 +72,7 @@ fn insert_doubly_oob(idx: usize, next_to: bool) {
         _ => 4,
     };
     let _ = list.try_remove(&indices[idx]);
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals(vec.iter().copied()));
 

tests/insert_at.rs

@@ -7,14 +7,17 @@ use test_case::test_matrix;
 ])]
 fn insert_at_singly<M: MemoryPolicy<Singly<char>>>(mut list: List<Singly<char>, M>) {
     list.insert_at(0, 'a');
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals(['a', 'b', 'c', 'd']));
 
     list.insert_at(4, 'e');
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals(['a', 'b', 'c', 'd', 'e']));
 
     list.insert_at(3, 'x');
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals(['a', 'b', 'c', 'x', 'd', 'e']));
 }
@@ -32,14 +35,17 @@ fn insert_at_singly_oob() {
 ])]
 fn insert_at_doubly<M: MemoryPolicy<Doubly<char>>>(mut list: List<Doubly<char>, M>) {
     list.insert_at(0, 'a');
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals(['a', 'b', 'c', 'd']));
 
     list.insert_at(4, 'e');
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals(['a', 'b', 'c', 'd', 'e']));
 
     list.insert_at(3, 'x');
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals(['a', 'b', 'c', 'x', 'd', 'e']));
 }
@@ -57,14 +63,17 @@ fn insert_at_doubly_oob() {
 ])]
 fn insert_at_from_back_doubly<M: MemoryPolicy<Doubly<char>>>(mut list: List<Doubly<char>, M>) {
     list.insert_at_from_back(0, 'e');
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals(['b', 'c', 'd', 'e']));
 
     list.insert_at_from_back(4, 'a');
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals(['a', 'b', 'c', 'd', 'e']));
 
     list.insert_at_from_back(2, 'x');
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals(['a', 'b', 'c', 'x', 'd', 'e']));
 }

tests/iter_from.rs

@@ -23,6 +23,7 @@ fn iter_from_singly() {
 
     let vec_slice = &vec[index_of_42..];
     let mut list_slice = list.iter_from(&idx42);
+    #[cfg(feature = "validation")]
     list.validate();
 
     for x in vec_slice {
@@ -60,6 +61,7 @@ fn iter_from_doubly() {
 
     let vec_slice = &vec[index_of_42..];
     let mut list_slice = list.iter_from(&idx42);
+    #[cfg(feature = "validation")]
     list.validate();
 
     for x in vec_slice {
@@ -97,6 +99,7 @@ fn iter_backward_from_doubly() {
 
     let vec_slice = &vec[0..=index_of_42];
     let mut list_slice = list.iter_backward_from(&idx42);
+    #[cfg(feature = "validation")]
     list.validate();
 
     for x in vec_slice.iter().rev() {

tests/list_move_next_to.rs

@@ -16,6 +16,7 @@ fn list_move_next_to_front() {
         let mut vec: Vec<_> = (0..n).into_iter().filter(|x| x != &i).collect();
         vec.insert(1, i);
 
+        #[cfg(feature = "validation")]
         list.validate();
         assert!(list.eq_to_iter_refs(&vec));
     }
@@ -33,6 +34,7 @@ fn list_move_next_to_back() {
 
         dbg!(i, &vec, list.iter().collect::<Vec<_>>());
 
+        #[cfg(feature = "validation")]
         list.validate();
         assert!(list.eq_to_iter_refs(&vec));
     }
@@ -42,16 +44,19 @@ fn list_move_next_to_back() {
 fn list_move_next_front_prev_to_arbitrary() {
     let (mut list, idx) = list_and_indices(5);
     list.move_next_to(&idx[0], &idx[2]);
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals([1, 2, 0, 3, 4]));
 
     let (mut list, idx) = list_and_indices(5);
     list.move_next_to(&idx[0], &idx[3]);
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals([1, 2, 3, 0, 4]));
 
     let (mut list, idx) = list_and_indices(5);
     list.move_next_to(&idx[0], &idx[4]);
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals([1, 2, 3, 4, 0]));
 }
@@ -60,16 +65,19 @@ fn list_move_next_front_prev_to_arbitrary() {
 fn list_move_next_back_prev_to_arbitrary() {
     let (mut list, idx) = list_and_indices(5);
     list.move_next_to(&idx[4], &idx[2]);
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals([0, 1, 2, 4, 3]));
 
     let (mut list, idx) = list_and_indices(5);
     list.move_next_to(&idx[4], &idx[0]);
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals([0, 4, 1, 2, 3]));
 
     let (mut list, idx) = list_and_indices(5);
     list.move_next_to(&idx[4], &idx[1]);
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals([0, 1, 4, 2, 3]));
 }
@@ -78,16 +86,19 @@ fn list_move_next_back_prev_to_arbitrary() {
 fn list_move_next_to_arbitrary() {
     let (mut list, idx) = list_and_indices(5);
     list.move_next_to(&idx[3], &idx[2]);
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals([0, 1, 2, 3, 4]));
 
     let (mut list, idx) = list_and_indices(5);
     list.move_next_to(&idx[3], &idx[0]);
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals([0, 3, 1, 2, 4]));
 
     let (mut list, idx) = list_and_indices(5);
     list.move_next_to(&idx[1], &idx[3]);
+    #[cfg(feature = "validation")]
     list.validate();
     assert!(list.eq_to_iter_vals([0, 2, 3, 1, 4]));
 }