Make node idx send and sync

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "orx-linked-list"
-version = "3.10.0"
+version = "4.0.0"
 edition = "2024"
 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."
@@ -16,7 +16,7 @@ orx-pinned-vec = { version = "3.21.0", default-features = false }
 orx-fixed-vec = { version = "3.22.0", default-features = false }
 orx-split-vec = { version = "3.22.0", default-features = false }
 orx-concurrent-iter = { version = "3.1.0", default-features = false }
-orx-selfref-col = { version = "2.14.0", default-features = false }
+orx-selfref-col = { git = "https://github.com/orxfun/orx-selfref-col.git", branch = "make-NodeIdx-Send", default-features = false }
 orx-parallel = { version = "3.3.0", default-features = false, optional = true }
 
 [dev-dependencies]

benches/doubly_shuffling_around.rs

@@ -89,9 +89,9 @@ struct TourLinkedList {
 
 impl TourLinkedList {
     fn insert_after(&mut self, city: usize, city_to_succeed: usize) {
-        let a = &self.idx[city];
-        let b = &self.idx[city_to_succeed];
-        self.cities.move_next_to(&a, &b);
+        let a = self.idx[city];
+        let b = self.idx[city_to_succeed];
+        self.cities.move_next_to(a, b);
     }
 
     fn create_tour(num_cities: usize, moves: &[(usize, usize)]) -> Self {

examples/tour_mutations.rs

@@ -117,9 +117,9 @@ impl Debug for TourLinkedList {
 
 impl TourLinkedList {
     fn insert_after(&mut self, city: usize, city_to_succeed: usize) {
-        let a = &self.idx[city];
-        let b = &self.idx[city_to_succeed];
-        self.cities.move_next_to(&a, &b);
+        let a = self.idx[city];
+        let b = self.idx[city_to_succeed];
+        self.cities.move_next_to(a, b);
     }
 
     fn create_tour(num_cities: usize, num_moves: usize) -> Self {

src/iter/doubly_iter.rs

@@ -34,7 +34,7 @@ where
     fn next(&mut self) -> Option<Self::Item> {
         self.0
             .next()
-            .map(|p| unsafe { self.0.col.data_unchecked(&p) })
+            .map(|p| unsafe { self.0.col.data_unchecked(p) })
     }
 }
 
@@ -46,7 +46,7 @@ where
     fn next_back(&mut self) -> Option<Self::Item> {
         self.0
             .next_back()
-            .map(|p| unsafe { self.0.col.data_unchecked(&p) })
+            .map(|p| unsafe { self.0.col.data_unchecked(p) })
     }
 }
 

src/iter/doubly_iter_mut.rs

@@ -53,11 +53,11 @@ where
     type Item = &'a mut T;
 
     fn next(&mut self) -> Option<Self::Item> {
-        match &self.current {
+        match self.current {
             Some(p) => {
-                let ptr = p.ptr_mut();
+                let ptr = unsafe { p.ptr_mut() };
                 match self.current == self.current_back {
-                    false => self.current = self.col.node(p).next().get().cloned(),
+                    false => self.current = self.col.node(p).next().get(),
                     true => self.end(),
                 }
 
@@ -73,11 +73,12 @@ where
     P: PinnedVec<Node<Doubly<T>>>,
 {
     fn next_back(&mut self) -> Option<Self::Item> {
-        match &self.current_back {
+        match self.current_back {
             Some(p) => {
-                let ptr = p.ptr_mut();
+                // SAFETY: collection as alive as guaranteed by the `col` field.
+                let ptr = unsafe { p.ptr_mut() };
                 match self.current == self.current_back {
-                    false => self.current_back = self.col.node(p).prev().get().cloned(),
+                    false => self.current_back = self.col.node(p).prev().get(),
                     true => self.end(),
                 }
                 unsafe { &mut *ptr }.data_mut()

src/iter/doubly_iter_mut_chain.rs

@@ -26,7 +26,7 @@ where
         first: [Option<NodePtr<Doubly<T>>>; 2],
         second: [Option<NodePtr<Doubly<T>>>; 2],
     ) -> Self {
-        let iter = DoublyIterMut::new(col, first[0].clone(), first[1].clone());
+        let iter = DoublyIterMut::new(col, first[0], first[1]);
         let [second_front, second_back] = second;
         Self {
             iter,
@@ -50,8 +50,7 @@ where
                 true => None,
                 false => {
                     self.consumed_first = true;
-                    self.iter
-                        .restart_for(self.second_front.clone(), self.second_back.clone());
+                    self.iter.restart_for(self.second_front, self.second_back);
                     self.iter.next()
                 }
             },

src/iter/doubly_iter_owned.rs

@@ -20,8 +20,8 @@ where
     P: PinnedVec<Node<Doubly<T>>>,
 {
     pub(crate) fn new(col: CoreCol<Doubly<T>, P>) -> Self {
-        let current = col.ends().get(0).cloned();
-        let current_back = col.ends().get(1).cloned();
+        let current = col.ends().get(0);
+        let current_back = col.ends().get(1);
         Self {
             col,
             current,
@@ -42,11 +42,11 @@ where
     type Item = T;
 
     fn next(&mut self) -> Option<Self::Item> {
-        match &self.current {
+        match self.current {
             Some(p) => {
-                let ptr = p.ptr_mut();
+                let ptr = unsafe { p.ptr_mut() };
                 match self.current == self.current_back {
-                    false => self.current = self.col.node(p).next().get().cloned(),
+                    false => self.current = self.col.node(p).next().get(),
                     true => self.end(),
                 }
 
@@ -62,11 +62,12 @@ where
     P: PinnedVec<Node<Doubly<T>>>,
 {
     fn next_back(&mut self) -> Option<Self::Item> {
-        match &self.current_back {
+        match self.current_back {
             Some(p) => {
-                let ptr = p.ptr_mut();
+                // SAFETY: collection as alive as guaranteed by the `col` field.
+                let ptr = unsafe { p.ptr_mut() };
                 match self.current == self.current_back {
-                    false => self.current_back = self.col.node(p).prev().get().cloned(),
+                    false => self.current_back = self.col.node(p).prev().get(),
                     true => self.end(),
                 }
 

src/iter/doubly_iter_ptr.rs

@@ -44,11 +44,11 @@ where
     type Item = NodePtr<Doubly<T>>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        match &self.current {
+        match self.current {
             Some(p) => {
-                let ptr = Some(p.clone());
+                let ptr = Some(p);
                 match self.current == self.current_back {
-                    false => self.current = self.col.node(p).next().get().cloned(),
+                    false => self.current = self.col.node(p).next().get(),
                     true => self.end(),
                 }
 
@@ -64,12 +64,12 @@ where
     P: PinnedVec<Node<Doubly<T>>>,
 {
     fn next_back(&mut self) -> Option<Self::Item> {
-        match &self.current_back {
+        match self.current_back {
             Some(p) => {
-                let ptr = Some(p.clone());
+                let ptr = Some(p);
 
                 match self.current == self.current_back {
-                    false => self.current_back = self.col.node(p).prev().get().cloned(),
+                    false => self.current_back = self.col.node(p).prev().get(),
                     true => self.end(),
                 }
 
@@ -89,8 +89,8 @@ where
     fn clone(&self) -> Self {
         Self {
             col: self.col,
-            current: self.current.clone(),
-            current_back: self.current_back.clone(),
+            current: self.current,
+            current_back: self.current_back,
         }
     }
 }

src/iter/doubly_link_iter.rs

@@ -33,8 +33,8 @@ where
     #[inline(always)]
     fn next(&mut self) -> Option<Self::Item> {
         self.0.next().map(|p| {
-            (unsafe { self.0.col.data_unchecked(&p.0) }, unsafe {
-                self.0.col.data_unchecked(&p.1)
+            (unsafe { self.0.col.data_unchecked(p.0) }, unsafe {
+                self.0.col.data_unchecked(p.1)
             })
         })
     }

src/iter/doubly_link_iter_ptr.rs

@@ -46,14 +46,13 @@ where
     type Item = PairPtr<T>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        match &self.current {
+        match self.current {
             Some(p) => {
-                let (prev, curr) = p.clone();
+                let (prev, curr) = p;
                 match Some(&curr) == self.current_back.as_ref() {
                     false => {
-                        //
-                        let next = self.col.node(&curr).next().get().cloned();
-                        let new_current = next.map(|next| (curr.clone(), next));
+                        let next = self.col.node(curr).next().get();
+                        let new_current = next.map(|next| (curr, next));
                         self.current = new_current;
                     }
                     true => self.end(),
@@ -75,8 +74,8 @@ where
     fn clone(&self) -> Self {
         Self {
             col: self.col,
-            current: self.current.clone(),
-            current_back: self.current_back.clone(),
+            current: self.current,
+            current_back: self.current_back,
         }
     }
 }

src/iter/singly_iter.rs

@@ -30,7 +30,7 @@ where
     fn next(&mut self) -> Option<Self::Item> {
         self.0
             .next()
-            .map(|p| unsafe { self.0.col.data_unchecked(&p) })
+            .map(|p| unsafe { self.0.col.data_unchecked(p) })
     }
 }
 

src/iter/singly_iter_mut.rs

@@ -19,7 +19,7 @@ where
     P: PinnedVec<Node<Singly<T>>>,
 {
     pub(crate) fn new_old(col: &'a mut CoreCol<Singly<T>, P>) -> Self {
-        let current = col.ends().get().cloned();
+        let current = col.ends().get();
         Self { col, current }
     }
 
@@ -38,10 +38,11 @@ where
     type Item = &'a mut T;
 
     fn next(&mut self) -> Option<Self::Item> {
-        match &self.current {
+        match self.current {
             Some(p) => {
-                let ptr = p.ptr_mut();
-                self.current = self.col.node(p).next().get().cloned();
+                // SAFETY: collection as alive as guaranteed by the `col` field.
+                let ptr = unsafe { p.ptr_mut() };
+                self.current = self.col.node(p).next().get();
                 unsafe { &mut *ptr }.data_mut()
             }
             None => None,

src/iter/singly_iter_owned.rs

@@ -19,7 +19,7 @@ where
     P: PinnedVec<Node<Singly<T>>>,
 {
     pub(crate) fn new(col: CoreCol<Singly<T>, P>) -> Self {
-        let current = col.ends().get().cloned();
+        let current = col.ends().get();
         Self { col, current }
     }
 }
@@ -31,10 +31,11 @@ where
     type Item = T;
 
     fn next(&mut self) -> Option<Self::Item> {
-        match &self.current {
+        match self.current {
             Some(p) => {
-                let ptr = p.ptr_mut();
-                self.current = self.col.node(p).next().get().cloned();
+                // SAFETY: collection as alive as guaranteed by the `col` field.
+                let ptr = unsafe { p.ptr_mut() };
+                self.current = self.col.node(p).next().get();
                 unsafe { &mut *ptr }.take_data()
             }
             None => None,

src/iter/singly_iter_ptr.rs

@@ -30,10 +30,10 @@ where
     type Item = NodePtr<Singly<T>>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        match &self.current {
+        match self.current {
             Some(p) => {
-                let ptr = Some(p.clone());
-                self.current = self.col.node(p).next().get().cloned();
+                let ptr = Some(p);
+                self.current = self.col.node(p).next().get();
                 ptr
             }
             None => None,
@@ -50,7 +50,7 @@ where
     fn clone(&self) -> Self {
         Self {
             col: self.col,
-            current: self.current.clone(),
+            current: self.current,
         }
     }
 }