ListSliceMut

orx_linked_list

Struct ListSliceMut 

Source 
pub struct ListSliceMut<'a, V, M = MemoryReclaimOnThreshold<2, V, V::Reclaimer>, P = SplitVec<Node<V>, Recursive>>
where
    V: ListVariant,
    M: MemoryPolicy<V>,
    P: PinnedVec<Node<V>>,
{ /* private fields */ }
Expand description

A mutable slice of a linked list.

Note that a list slice itself behaves pretty much like a linked list. However, it does not own the data, but provides a view on it, just as a slice of a vec.

Trait Implementations§

Source§

impl<'i, T, M, P> Index<&'i NodeIdx<Doubly<T>>> for ListSliceMut<'_, Doubly<T>, M, P>
where M: MemoryPolicy<Doubly<T>>, P: PinnedVec<Node<Doubly<T>>>,

Source§

fn index(&self, index: &'i DoublyIdx<T>) -> &Self::Output

Returns the element at the given index.

§Panics

Panics if the index is invalid; i.e.,

  • list.is_valid(index) returns false, equivalently,
  • list.idx_err(index) returns the detail of the error.
Source§

type Output = T

The returned type after indexing.
Source§

impl<'i, T, M, P> Index<&'i NodeIdx<Singly<T>>> for ListSliceMut<'_, Singly<T>, M, P>
where M: MemoryPolicy<Singly<T>>, P: PinnedVec<Node<Singly<T>>>,

Source§

fn index(&self, index: &'i SinglyIdx<T>) -> &Self::Output

Returns the element at the given index.

§Panics

Panics if the index is invalid; i.e.,

  • list.is_valid(index) returns false, equivalently,
  • list.idx_err(index) returns the detail of the error.
Source§

type Output = T

The returned type after indexing.
Source§

impl<'i, T, M, P> IndexMut<&'i NodeIdx<Doubly<T>>> for ListSliceMut<'_, Doubly<T>, M, P>
where M: MemoryPolicy<Doubly<T>>, P: PinnedVec<Node<Doubly<T>>>,

Source§

fn index_mut(&mut self, index: &'i DoublyIdx<T>) -> &mut Self::Output

Returns a mutable reference to the element at the given index.

§Panics

Panics if the index is invalid; i.e.,

  • list.is_valid(index) returns false, equivalently,
  • list.idx_err(index) returns the detail of the error.
Source§

impl<'i, T, M, P> IndexMut<&'i NodeIdx<Singly<T>>> for ListSliceMut<'_, Singly<T>, M, P>
where M: MemoryPolicy<Singly<T>>, P: PinnedVec<Node<Singly<T>>>,

Source§

fn index_mut(&mut self, index: &'i SinglyIdx<T>) -> &mut Self::Output

Returns a mutable reference to the element at the given index.

§Panics

Panics if the index is invalid; i.e.,

  • list.is_valid(index) returns false, equivalently,
  • list.idx_err(index) returns the detail of the error.

Auto Trait Implementations§

§

impl<'a, V, M, P> Freeze for ListSliceMut<'a, V, M, P>
where <V as Variant>::Ends: Freeze,

§

impl<'a, V, M, P> RefUnwindSafe for ListSliceMut<'a, V, M, P>
where <V as Variant>::Ends: RefUnwindSafe, M: RefUnwindSafe, P: RefUnwindSafe,

§

impl<'a, V, M, P> Send for ListSliceMut<'a, V, M, P>
where <V as Variant>::Ends: Send, M: Send, P: Send,

§

impl<'a, V, M, P> Sync for ListSliceMut<'a, V, M, P>
where <V as Variant>::Ends: Sync, M: Sync, P: Sync,

§

impl<'a, V, M, P> Unpin for ListSliceMut<'a, V, M, P>
where <V as Variant>::Ends: Unpin,

§

impl<'a, V, M = MemoryReclaimOnThreshold<2, V, <V as ListVariant>::Reclaimer>, P = SplitVec<Node<V>, Recursive>> !UnwindSafe for ListSliceMut<'a, V, M, P>

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<L, T, M, P> DoublyEnds<T, M, P> for L
where L: HasDoublyEnds<T, M, P>, M: MemoryPolicy<Doubly<T>>, P: PinnedVec<Node<Doubly<T>>>,

Source§

fn front<'a>(&'a self) -> Option<&'a T>
where M: 'a, P: 'a,

O(1) Returns a reference to the front of the list. Read more
Source§

fn back<'a>(&'a self) -> Option<&'a T>
where M: 'a, P: 'a,

O(1) Returns a reference to the back of the list. Read more
Source§

fn idx_err(&self, idx: &DoublyIdx<T>) -> Option<NodeIdxError>

O(1) Returns a None if the given node idx is valid. Read more
Source§

fn is_valid(&self, idx: &DoublyIdx<T>) -> bool

O(1) Returns whether or not the idx is valid for this list; i.e., Read more
Source§

fn get<'a>(&'a self, idx: &DoublyIdx<T>) -> Option<&'a T>
where M: 'a, P: 'a,

O(1) Returns a reference to the node with the given idx in constant time. Read more
Source§

fn try_get<'a>(&'a self, idx: &DoublyIdx<T>) -> Result<&'a T, NodeIdxError>
where M: 'a, P: 'a,

O(1) Returns a reference to the node with the given idx in constant time. Read more
Source§

fn next_idx_of(&self, idx: &DoublyIdx<T>) -> Option<DoublyIdx<T>>

O(1) Returns the index of the element succeeding the one with the given idx. Returns None if the element at idx is the back. Read more
Source§

fn next_of<'a>(&'a self, idx: &DoublyIdx<T>) -> Option<&'a T>
where M: 'a, P: 'a,

O(1) Returns the element succeeding the one with the given idx. Returns None if the element at idx is the back. Read more
Source§

fn prev_idx_of(&self, idx: &DoublyIdx<T>) -> Option<DoublyIdx<T>>

O(1) Returns the index of the element preceding the one with the given idx. Returns None if the element at idx is the front. Read more
Source§

fn prev_of<'a>(&'a self, idx: &DoublyIdx<T>) -> Option<&'a T>
where M: 'a, P: 'a,

O(1) Returns the element preceding the one with the given idx. Returns None if the element at idx is the front. Read more
Source§

impl<L, T, M, P> DoublyEndsMut<T, M, P> for L
where L: HasDoublyEndsMut<T, M, P>, M: MemoryPolicy<Doubly<T>>, P: PinnedVec<Node<Doubly<T>>>,

Source§

fn front_mut<'a>(&'a mut self) -> Option<&'a mut T>
where M: 'a, P: 'a,

O(1) Returns a mutable reference to the front of the list, returns None if the list is empty. Read more
Source§

fn back_mut<'a>(&'a mut self) -> Option<&'a mut T>
where M: 'a, P: 'a,

O(1) Returns a mutable reference to the back of the list, returns None if the list is empty. Read more
Source§

fn get_mut<'a>(&'a mut self, idx: &DoublyIdx<T>) -> Option<&'a mut T>
where M: 'a, P: 'a,

O(1) Returns a mutable reference to the node with the given idx in constant time. Read more
Source§

fn try_get_mut<'a>( &'a mut self, idx: &DoublyIdx<T>, ) -> Result<&'a mut T, NodeIdxError>
where M: 'a, P: 'a,

O(1) Returns a mutable reference to the node with the given idx in constant time. Read more
Source§

fn next_mut_of<'a>(&'a mut self, idx: &DoublyIdx<T>) -> Option<&'a mut T>
where M: 'a, P: 'a,

O(1) Returns a mutable reference to the element succeeding the one with the given idx. Returns None if the element at idx is the back. Read more
Source§

fn prev_mut_of<'a>(&'a mut self, idx: &DoublyIdx<T>) -> Option<&'a mut T>
where M: 'a, P: 'a,

O(1) Returns a mutable reference to the element preceding the one with the given idx. Returns None if the element at idx is the front. Read more
Source§

fn reverse(&mut self)

O(n) Reverses the list (in-place). Read more
Source§

fn move_next_to(&mut self, idx: &DoublyIdx<T>, idx_target: &DoublyIdx<T>)

O(1) Moves the element with the given idx immediately after the target element with the given idx_target. Read more
Source§

fn move_prev_to(&mut self, idx: &DoublyIdx<T>, idx_target: &DoublyIdx<T>)

O(1) Moves the element with the given idx immediately before the target element with the given idx_target. Read more
Source§

fn move_to_front(&mut self, idx: &DoublyIdx<T>)

O(1) Moves the element with the given idx to the front of the list. Read more
Source§

fn move_to_back(&mut self, idx: &DoublyIdx<T>)

O(1) Moves the element with the given idx to the back of the list. Read more
Source§

fn swap(&mut self, idx_a: &DoublyIdx<T>, idx_b: &DoublyIdx<T>)

O(1) Swaps the elements with indices a and b. Read more
O(1) Adds a link between a and b; i.e., Read more
O(1) Removes a link between a and b; i.e., Read more
Source§

unsafe fn set_front(&mut self, new_front: &DoublyIdx<T>)

O(1) Sets the front of the list as the new_front. Read more
Source§

unsafe fn set_back(&mut self, new_back: &DoublyIdx<T>)

O(1) Sets the back of the list as the new_back. Read more
Source§

impl<L, T, M, P> DoublyIterable<T, M, P> for L
where P: PinnedVec<Node<Doubly<T>>>, L: HasDoublyEnds<T, M, P>, M: MemoryPolicy<Doubly<T>>,

Source§

fn iter_ptr<'a>(&'a self) -> DoublyIterPtr<'a, T, P> ⓘ
where M: 'a,

Returns a double-ended iterator of pointers to the elements of the list from front to back.
Source§

fn iter<'a>(&'a self) -> DoublyIter<'a, T, P> ⓘ
where M: 'a,

Returns a double-ended iterator to elements of the list: Read more
Creates a forward iterator that yields pairs of successive elements representing links. Read more
Source§

fn indices<'a>(&'a self) -> impl Iterator<Item = DoublyIdx<T>>
where M: 'a, T: 'a, P: 'a,

Returns an iterator of indices of elements of the list. Read more
Source§

fn pointers<'a>(&'a self) -> impl Iterator<Item = DoublyPtr<T>>
where M: 'a, T: 'a, P: 'a,

Returns an iterator of pointers to the elements of the list. Read more
Source§

fn ring_iter<'a>( &'a self, pivot_idx: &DoublyIdx<T>, ) -> Chain<DoublyIter<'a, T, P>, DoublyIter<'a, T, P>>
where M: 'a,

Creates a forward iterator starting from the pivot_idx and ending at the element before it. Read more
Source§

fn iter_from<'a>(&'a self, idx: &DoublyIdx<T>) -> DoublyIter<'a, T, P> ⓘ
where M: 'a,

Creates a forward iterator: Read more
Source§

fn iter_backward_from<'a>( &'a self, idx: &DoublyIdx<T>, ) -> Rev<DoublyIter<'a, T, P>>
where M: 'a,

Creates a backward iterator: Read more
Creates a forward iterator that yields pairs of successive elements representing links: Read more
Source§

fn eq_to_iter_vals<I>(&self, iter: I) -> bool
where I: IntoIterator<Item = T>, T: PartialEq,

Returns true if the elements of the iterator are equal to those of the list.
Source§

fn eq_to_iter_refs<'a, I>(&self, iter: I) -> bool
where I: IntoIterator<Item = &'a T>, T: 'a + PartialEq,

Returns true if the elements of the iterator are equal to those of the list.
Source§

impl<L, T, M, P> DoublyIterableMut<T, M, P> for L
where L: HasDoublyEndsMut<T, M, P>, M: MemoryPolicy<Doubly<T>>, P: PinnedVec<Node<Doubly<T>>>,

Source§

fn iter_mut<'a>(&'a mut self) -> DoublyIterMut<'a, T, P> ⓘ
where M: 'a,

Returns a double-ended iterator of mutable references to elements of the list from front to back. Read more
Source§

fn iter_mut_from<'a>( &'a mut self, idx: &DoublyIdx<T>, ) -> DoublyIterMut<'a, T, P> ⓘ
where M: 'a,

Creates a mutable forward iterator: Read more
Source§

fn iter_mut_backward_from<'a>( &'a mut self, idx: &DoublyIdx<T>, ) -> Rev<DoublyIterMut<'a, T, P>>
where M: 'a,

Creates a mutable backward iterator: Read more
Source§

fn ring_iter_mut<'a>( &'a mut self, pivot_idx: &DoublyIdx<T>, ) -> DoublyIterMutChain<'a, T, P> ⓘ
where M: 'a,

Creates a mutable forward iterator starting from the pivot_idx and ending at the element before it. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<L, T, M, P> SinglyEnds<T, M, P> for L
where L: HasSinglyEnds<T, M, P>, M: MemoryPolicy<Singly<T>>, P: PinnedVec<Node<Singly<T>>>,

Source§

fn front<'a>(&'a self) -> Option<&'a T>
where M: 'a, P: 'a,

O(1) Returns a reference to the front of the list. Read more
Source§

fn idx_err(&self, idx: &SinglyIdx<T>) -> Option<NodeIdxError>

O(1) Returns a None if the given node idx is valid. Read more
Source§

fn is_valid(&self, idx: &SinglyIdx<T>) -> bool

O(1) Returns whether or not the idx is valid for this list; i.e., Read more
Source§

fn get<'a>(&'a self, idx: &SinglyIdx<T>) -> Option<&'a T>
where M: 'a, P: 'a,

O(1) Returns a reference to the node with the given idx in constant time. Read more
Source§

fn try_get<'a>(&'a self, idx: &SinglyIdx<T>) -> Result<&'a T, NodeIdxError>
where M: 'a, P: 'a,

O(1) Returns a reference to the node with the given idx in constant time. Read more
Source§

fn next_idx_of(&self, idx: &SinglyIdx<T>) -> Option<SinglyIdx<T>>

O(1) Returns the index of the element succeeding the one with the given idx. Returns None if the element at idx is the back. Read more
Source§

fn next_of<'a>(&'a self, idx: &SinglyIdx<T>) -> Option<&'a T>
where M: 'a, P: 'a,

O(1) Returns the element succeeding the one with the given idx. Returns None if the element at idx is the back. Read more
Source§

impl<L, T, M, P> SinglyEndsMut<T, M, P> for L
where L: HasSinglyEndsMut<T, M, P>, M: MemoryPolicy<Singly<T>>, P: PinnedVec<Node<Singly<T>>>,

Source§

fn front_mut<'a>(&'a mut self) -> Option<&'a mut T>
where M: 'a, P: 'a,

O(1) Returns a mutable reference to the front of the list, returns None if the list is empty. Read more
Source§

fn get_mut<'a>(&'a mut self, idx: &SinglyIdx<T>) -> Option<&'a mut T>
where M: 'a, P: 'a,

O(1) Returns a mutable reference to the node with the given idx in constant time. Read more
Source§

fn try_get_mut<'a>( &'a mut self, idx: &SinglyIdx<T>, ) -> Result<&'a mut T, NodeIdxError>
where M: 'a, P: 'a,

O(1) Returns a mutable reference to the node with the given idx in constant time. Read more
Source§

fn next_mut_of<'a>(&'a mut self, idx: &SinglyIdx<T>) -> Option<&'a mut T>
where M: 'a, P: 'a,

O(1) Returns a mutable reference to the element succeeding the one with the given idx. Returns None if the element at idx is the back. Read more
Source§

impl<L, T, M, P> SinglyIterable<T, M, P> for L
where L: HasSinglyEnds<T, M, P>, M: MemoryPolicy<Singly<T>>, P: PinnedVec<Node<Singly<T>>>,

Source§

fn iter_ptr<'a>(&'a self) -> SinglyIterPtr<'a, T, P> ⓘ
where M: 'a,

Returns a double-ended iterator of pointers to the elements of the list from front to back.
Source§

fn iter<'a>(&'a self) -> SinglyIter<'a, T, P> ⓘ
where M: 'a,

Returns a forward iterator to elements of the list from front to back. Read more
Source§

fn indices<'a>(&'a self) -> impl Iterator<Item = SinglyIdx<T>>
where M: 'a, T: 'a, P: 'a,

Returns an iterator of indices of elements of the list. Read more
Source§

fn pointers<'a>(&'a self) -> impl Iterator<Item = SinglyPtr<T>>
where M: 'a, T: 'a, P: 'a,

Returns an iterator of pointers to the elements of the list. Read more
Source§

fn iter_from<'a>(&'a self, idx: &SinglyIdx<T>) -> SinglyIter<'a, T, P> ⓘ
where M: 'a,

Creates a forward iterator: Read more
Source§

fn eq_to_iter_vals<I>(&self, iter: I) -> bool
where I: IntoIterator<Item = T>, T: PartialEq,

Returns true if the elements of the iterator are equal to those of the list.
Source§

fn eq_to_iter_refs<'a, I>(&self, iter: I) -> bool
where I: IntoIterator<Item = &'a T>, T: 'a + PartialEq,

Returns true if the elements of the iterator are equal to those of the list.
Source§

impl<L, T, M, P> SinglyIterableMut<T, M, P> for L
where L: HasSinglyEndsMut<T, M, P>, M: MemoryPolicy<Singly<T>>, P: PinnedVec<Node<Singly<T>>>,

Source§

fn iter_mut<'a>(&'a mut self) -> SinglyIterMut<'a, T, P> ⓘ
where M: 'a,

Returns a double-ended iterator of mutable references to elements of the list from front to back. Read more
Source§

fn iter_mut_from<'a>( &'a mut self, idx: &SinglyIdx<T>, ) -> SinglyIterMut<'a, T, P> ⓘ
where M: 'a,

Creates a mutable forward iterator: Read more
Source§

impl<T> SoM<T> for T

Source§

fn get_ref(&self) -> &T

Returns a reference to self.
Source§

fn get_mut(&mut self) -> &mut T

Returns a mutable reference to self.
Source§

impl<T> SoR<T> for T

Source§

fn get_ref(&self) -> &T

Returns a reference to self.
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.