Merge pull request #35 from orxfun/list-made-generic-over-pinned-vec-storage

List made generic over pinned vec storage

Author: orxfun

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "orx-linked-list"
-version = "3.0.1"
+version = "3.1.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."
@@ -13,7 +13,8 @@ categories = ["data-structures", "rust-patterns", "no-std"]
 orx-pseudo-default = { version = "1.4", default-features = false }
 orx-pinned-vec = "3.9"
 orx-split-vec = "3.9"
-orx-selfref-col = "2.0"
+orx-fixed-vec = "3.9"
+orx-selfref-col = "2.1"
 
 [dev-dependencies]
 clap = { version = "4.5.17", features = ["derive"] }

examples/tour_mutations.rs

@@ -144,7 +144,7 @@ fn timed<R, F: FnOnce() -> R>(run: F) -> (R, u128) {
     (result, ms)
 }
 
-/// Simple program to greet a person
+/// Program demonstrating different tour representations.
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
 struct Args {

src/iter/doubly_iter.rs

@@ -1,24 +1,33 @@
 use super::doubly_iter_ptr::DoublyIterPtr;
-use crate::{type_aliases::PinVec, Doubly};
+use crate::Doubly;
 use core::iter::FusedIterator;
-use orx_selfref_col::{CoreCol, NodePtr};
+use orx_pinned_vec::PinnedVec;
+use orx_selfref_col::{CoreCol, Node, NodePtr};
 
 /// An ordered iterator over elements of the doubly linked list.
 ///
 /// Can be created by calling the `iter` method.
-pub struct DoublyIter<'a, T>(DoublyIterPtr<'a, T>);
+pub struct DoublyIter<'a, T, P>(DoublyIterPtr<'a, T, P>)
+where
+    P: PinnedVec<Node<Doubly<T>>>;
 
-impl<'a, T> DoublyIter<'a, T> {
+impl<'a, T, P> DoublyIter<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     pub(crate) fn new(
-        col: &'a CoreCol<Doubly<T>, PinVec<Doubly<T>>>,
+        col: &'a CoreCol<Doubly<T>, P>,
         current: Option<NodePtr<Doubly<T>>>,
         current_back: Option<NodePtr<Doubly<T>>>,
     ) -> Self {
         Self(DoublyIterPtr::new(col, current, current_back))
     }
 }
 
-impl<'a, T> Iterator for DoublyIter<'a, T> {
+impl<'a, T, P> Iterator for DoublyIter<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     type Item = &'a T;
 
     #[inline(always)]
@@ -29,7 +38,10 @@ impl<'a, T> Iterator for DoublyIter<'a, T> {
     }
 }
 
-impl<'a, T> DoubleEndedIterator for DoublyIter<'a, T> {
+impl<'a, T, P> DoubleEndedIterator for DoublyIter<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     #[inline(always)]
     fn next_back(&mut self) -> Option<Self::Item> {
         self.0
@@ -38,9 +50,12 @@ impl<'a, T> DoubleEndedIterator for DoublyIter<'a, T> {
     }
 }
 
-impl<'a, T> FusedIterator for DoublyIter<'a, T> {}
+impl<'a, T, P> FusedIterator for DoublyIter<'a, T, P> where P: PinnedVec<Node<Doubly<T>>> {}
 
-impl<'a, T> Clone for DoublyIter<'a, T> {
+impl<'a, T, P> Clone for DoublyIter<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     fn clone(&self) -> Self {
         Self(self.0.clone())
     }

src/iter/doubly_iter_mut.rs

@@ -1,19 +1,26 @@
-use crate::{type_aliases::PinVec, Doubly};
+use crate::Doubly;
 use core::iter::FusedIterator;
-use orx_selfref_col::{CoreCol, NodePtr};
+use orx_pinned_vec::PinnedVec;
+use orx_selfref_col::{CoreCol, Node, NodePtr};
 
 /// An ordered iterator mutable references to elements of the doubly linked list.
 ///
 /// Can be created by calling the `iter_mut` method.
-pub struct DoublyIterMut<'a, T> {
-    col: &'a mut CoreCol<Doubly<T>, PinVec<Doubly<T>>>,
+pub struct DoublyIterMut<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
+    col: &'a mut CoreCol<Doubly<T>, P>,
     current: Option<NodePtr<Doubly<T>>>,
     current_back: Option<NodePtr<Doubly<T>>>,
 }
 
-impl<'a, T> DoublyIterMut<'a, T> {
+impl<'a, T, P> DoublyIterMut<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     pub(crate) fn new(
-        col: &'a mut CoreCol<Doubly<T>, PinVec<Doubly<T>>>,
+        col: &'a mut CoreCol<Doubly<T>, P>,
         current: Option<NodePtr<Doubly<T>>>,
         current_back: Option<NodePtr<Doubly<T>>>,
     ) -> Self {
@@ -39,7 +46,10 @@ impl<'a, T> DoublyIterMut<'a, T> {
     }
 }
 
-impl<'a, T> Iterator for DoublyIterMut<'a, T> {
+impl<'a, T, P> Iterator for DoublyIterMut<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     type Item = &'a mut T;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -58,7 +68,10 @@ impl<'a, T> Iterator for DoublyIterMut<'a, T> {
     }
 }
 
-impl<'a, T> DoubleEndedIterator for DoublyIterMut<'a, T> {
+impl<'a, T, P> DoubleEndedIterator for DoublyIterMut<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     fn next_back(&mut self) -> Option<Self::Item> {
         match &self.current_back {
             Some(p) => {
@@ -74,4 +87,4 @@ impl<'a, T> DoubleEndedIterator for DoublyIterMut<'a, T> {
     }
 }
 
-impl<'a, T> FusedIterator for DoublyIterMut<'a, T> {}
+impl<'a, T, P> FusedIterator for DoublyIterMut<'a, T, P> where P: PinnedVec<Node<Doubly<T>>> {}

src/iter/doubly_iter_mut_chain.rs

@@ -1,22 +1,28 @@
-use crate::{type_aliases::PinVec, Doubly};
-use core::iter::FusedIterator;
-use orx_selfref_col::{CoreCol, NodePtr};
-
 use super::DoublyIterMut;
+use crate::Doubly;
+use core::iter::FusedIterator;
+use orx_pinned_vec::PinnedVec;
+use orx_selfref_col::{CoreCol, Node, NodePtr};
 
 /// An ordered iterator mutable references to elements of the doubly linked list.
 ///
 /// Can be created by calling the `iter_mut` method.
-pub struct DoublyIterMutChain<'a, T> {
-    iter: DoublyIterMut<'a, T>,
+pub struct DoublyIterMutChain<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
+    iter: DoublyIterMut<'a, T, P>,
     second_front: Option<NodePtr<Doubly<T>>>,
     second_back: Option<NodePtr<Doubly<T>>>,
     consumed_first: bool,
 }
 
-impl<'a, T> DoublyIterMutChain<'a, T> {
+impl<'a, T, P> DoublyIterMutChain<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     pub(crate) fn new(
-        col: &'a mut CoreCol<Doubly<T>, PinVec<Doubly<T>>>,
+        col: &'a mut CoreCol<Doubly<T>, P>,
         first: [Option<NodePtr<Doubly<T>>>; 2],
         second: [Option<NodePtr<Doubly<T>>>; 2],
     ) -> Self {
@@ -31,7 +37,10 @@ impl<'a, T> DoublyIterMutChain<'a, T> {
     }
 }
 
-impl<'a, T> Iterator for DoublyIterMutChain<'a, T> {
+impl<'a, T, P> Iterator for DoublyIterMutChain<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     type Item = &'a mut T;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -50,4 +59,4 @@ impl<'a, T> Iterator for DoublyIterMutChain<'a, T> {
     }
 }
 
-impl<'a, T> FusedIterator for DoublyIterMutChain<'a, T> {}
+impl<'a, T, P> FusedIterator for DoublyIterMutChain<'a, T, P> where P: PinnedVec<Node<Doubly<T>>> {}

src/iter/doubly_iter_owned.rs

@@ -1,18 +1,25 @@
-use crate::{type_aliases::PinVec, Doubly};
+use crate::Doubly;
 use core::iter::FusedIterator;
-use orx_selfref_col::{CoreCol, NodePtr};
+use orx_pinned_vec::PinnedVec;
+use orx_selfref_col::{CoreCol, Node, NodePtr};
 
 /// An ordered consuming iterator of the doubly linked list.
 ///
 /// Can be created by calling the `into_iter` method.
-pub struct DoublyIterOwned<T> {
-    col: CoreCol<Doubly<T>, PinVec<Doubly<T>>>,
+pub struct DoublyIterOwned<T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
+    col: CoreCol<Doubly<T>, P>,
     current: Option<NodePtr<Doubly<T>>>,
     current_back: Option<NodePtr<Doubly<T>>>,
 }
 
-impl<T> DoublyIterOwned<T> {
-    pub(crate) fn new(col: CoreCol<Doubly<T>, PinVec<Doubly<T>>>) -> Self {
+impl<T, P> DoublyIterOwned<T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
+    pub(crate) fn new(col: CoreCol<Doubly<T>, P>) -> Self {
         let current = col.ends().get(0);
         let current_back = col.ends().get(1);
         Self {
@@ -28,7 +35,10 @@ impl<T> DoublyIterOwned<T> {
     }
 }
 
-impl<T> Iterator for DoublyIterOwned<T> {
+impl<T, P> Iterator for DoublyIterOwned<T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     type Item = T;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -47,7 +57,10 @@ impl<T> Iterator for DoublyIterOwned<T> {
     }
 }
 
-impl<T> DoubleEndedIterator for DoublyIterOwned<T> {
+impl<T, P> DoubleEndedIterator for DoublyIterOwned<T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     fn next_back(&mut self) -> Option<Self::Item> {
         match &self.current_back {
             Some(p) => {
@@ -64,4 +77,4 @@ impl<T> DoubleEndedIterator for DoublyIterOwned<T> {
     }
 }
 
-impl<T> FusedIterator for DoublyIterOwned<T> {}
+impl<T, P> FusedIterator for DoublyIterOwned<T, P> where P: PinnedVec<Node<Doubly<T>>> {}

src/iter/doubly_iter_ptr.rs

@@ -1,19 +1,26 @@
-use crate::{type_aliases::PinVec, Doubly};
+use crate::Doubly;
 use core::iter::FusedIterator;
-use orx_selfref_col::{CoreCol, NodePtr};
+use orx_pinned_vec::PinnedVec;
+use orx_selfref_col::{CoreCol, Node, NodePtr};
 
 /// An ordered iterator over pointers to the elements of the doubly linked list.
 ///
 /// Can be created by calling the `iter_ptr` method.
-pub struct DoublyIterPtr<'a, T> {
-    pub(crate) col: &'a CoreCol<Doubly<T>, PinVec<Doubly<T>>>,
+pub struct DoublyIterPtr<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
+    pub(crate) col: &'a CoreCol<Doubly<T>, P>,
     current: Option<NodePtr<Doubly<T>>>,
     current_back: Option<NodePtr<Doubly<T>>>,
 }
 
-impl<'a, T> DoublyIterPtr<'a, T> {
+impl<'a, T, P> DoublyIterPtr<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     pub(crate) fn new(
-        col: &'a CoreCol<Doubly<T>, PinVec<Doubly<T>>>,
+        col: &'a CoreCol<Doubly<T>, P>,
         current: Option<NodePtr<Doubly<T>>>,
         current_back: Option<NodePtr<Doubly<T>>>,
     ) -> Self {
@@ -30,7 +37,10 @@ impl<'a, T> DoublyIterPtr<'a, T> {
     }
 }
 
-impl<'a, T> Iterator for DoublyIterPtr<'a, T> {
+impl<'a, T, P> Iterator for DoublyIterPtr<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     type Item = NodePtr<Doubly<T>>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -49,7 +59,10 @@ impl<'a, T> Iterator for DoublyIterPtr<'a, T> {
     }
 }
 
-impl<'a, T> DoubleEndedIterator for DoublyIterPtr<'a, T> {
+impl<'a, T, P> DoubleEndedIterator for DoublyIterPtr<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     fn next_back(&mut self) -> Option<Self::Item> {
         match &self.current_back {
             Some(p) => {
@@ -67,9 +80,12 @@ impl<'a, T> DoubleEndedIterator for DoublyIterPtr<'a, T> {
     }
 }
 
-impl<'a, T> FusedIterator for DoublyIterPtr<'a, T> {}
+impl<'a, T, P> FusedIterator for DoublyIterPtr<'a, T, P> where P: PinnedVec<Node<Doubly<T>>> {}
 
-impl<'a, T> Clone for DoublyIterPtr<'a, T> {
+impl<'a, T, P> Clone for DoublyIterPtr<'a, T, P>
+where
+    P: PinnedVec<Node<Doubly<T>>>,
+{
     fn clone(&self) -> Self {
         Self {
             col: self.col,