Struct orx_selfref_col::Node

pub struct Node<'a, V, T>
where
    V: Variant<'a, T>,
{ /* private fields */ }

A node of the self referential collection.

Each node is composed of the following three pieces of data:

• data: V::Storage: data of the element
• prev: V::Prev: references to the previous nodes in the collection
• next: V::Next: references to the previous nodes in the collection

Implementations

impl<'a, V, T> Node<'a, V, T>

where V: Variant<'a, T, Storage = NodeDataLazyClose<T>>,

pub fn closed_node() -> Self

Creates a new closed node with no data and no prev and next references.

pub fn is_closed(&self) -> bool

Returns whether the node is closed or not.

impl<'a, V, T> Node<'a, V, T>

where V: Variant<'a, T>,

pub fn new_free_node(data: T) -> Self

Creates a new free node with the given data without any previous or next references.

pub fn new(data: V::Storage, prev: V::Prev, next: V::Next) -> Self

Creates a new node with the given data and prev and next references.

pub fn is_active(&self) -> bool

Returns whether the node is active, or closed otherwise.

pub fn data(&self) -> Option<&T>

Returns a reference to the data stored in the node; None if the node is closed.

pub fn prev(&self) -> &V::Prev

Returns a reference to previous references of the node.

pub fn next(&self) -> &V::Next

Returns a reference to next references of the node.

pub fn data_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the data stored in the node; None if the node is closed.

pub fn index<Collection>( &'a self, collection: &Collection ) -> NodeIndex<'a, V, T>

where Collection: HasCollectionKey<'a, V, T>,

Gets the index of the node.

This index can be:

• stored independent of the self referential collection as a value,
• used to safely access to this node in O(1) time.

pub fn swap_data<'rf, P>( &'a self, vec_mut: &SelfRefColMut<'rf, 'a, V, T, P>, new_value: T ) -> T

where P: PinnedVec<Node<'a, V, T>>,

Swaps the data stored in the node with the new_value and returns the old data.

Panics

Panics if the node is closed.

pub fn set_prev_refs<'rf, P>( &'a self, vec_mut: &SelfRefColMut<'rf, 'a, V, T, P>, prev: V::Prev )

where P: PinnedVec<Node<'a, V, T>>,

Updates the previous references of the node as the given prev.

pub fn set_next_refs<'rf, P>( &'a self, vec_mut: &SelfRefColMut<'rf, 'a, V, T, P>, next: V::Next )

where P: PinnedVec<Node<'a, V, T>>,

Updates the next references of the node as the given next.

pub fn set_next<'rf, P, Next: Into<V::Next>>( &'a self, vec_mut: &SelfRefColMut<'rf, 'a, V, T, P>, next: Next )

where P: PinnedVec<Node<'a, V, T>>,

Updates the next reference of the node as the given next.

pub fn set_prev<'rf, P, Prev: Into<V::Prev>>( &'a self, vec_mut: &SelfRefColMut<'rf, 'a, V, T, P>, prev: Prev )

where P: PinnedVec<Node<'a, V, T>>,

Updates the previous reference of the node as the given prev.

pub fn clear_next<'rf, P>(&'a self, vec_mut: &SelfRefColMut<'rf, 'a, V, T, P>)

where P: PinnedVec<Node<'a, V, T>>,

Clears next references of the node.

pub fn clear_prev<'rf, P>(&'a self, vec_mut: &SelfRefColMut<'rf, 'a, V, T, P>)

where P: PinnedVec<Node<'a, V, T>>,

Clears previous references of the node.

pub fn close_node_take_data<'rf, P>( &'a self, vec_mut: &SelfRefColMut<'rf, 'a, V, T, P> ) -> T

where V: Variant<'a, T, Storage = NodeDataLazyClose<T>>, P: PinnedVec<Node<'a, V, T>> + 'a, SelfRefColMut<'rf, 'a, V, T, P>: Reclaim<V::Prev, V::Next>,

Closes the lazy node, takes out and returns its data.

Panics

Panics if the node is already closed; i.e., if self.is_closed().

pub fn close_node_take_data_no_reclaim<'rf, P>( &'a self, vec_mut: &SelfRefColMut<'rf, 'a, V, T, P> ) -> T

where V: Variant<'a, T, Storage = NodeDataLazyClose<T>>, P: PinnedVec<Node<'a, V, T>> + 'a, SelfRefColMut<'rf, 'a, V, T, P>: Reclaim<V::Prev, V::Next>,

Closes the lazy node, takes out and returns its data. Skips memory reclaim operation regardless of the utilization.

Panics

Panics if the node is already closed; i.e., if self.is_closed().

pub fn prev_vec_mut<'rf, P>( &'a self, vec_mut: &SelfRefColMut<'rf, 'a, V, T, P> ) -> &mut Vec<&'a Node<'a, V, T>>

where V: Variant<'a, T, Prev = NodeRefsVec<'a, V, T>>, P: PinnedVec<Node<'a, V, T>>,

Returns a mutable reference to previous references of the node.

pub fn next_vec_mut<'rf, P>( &'a self, vec_mut: &SelfRefColMut<'rf, 'a, V, T, P> ) -> &mut Vec<&'a Node<'a, V, T>>

where V: Variant<'a, T, Next = NodeRefsVec<'a, V, T>>, P: PinnedVec<Node<'a, V, T>>,

Returns a mutable reference to next references of the node.

pub fn prev_array_mut<'rf, P, const N: usize>( &'a self, vec_mut: &SelfRefColMut<'rf, 'a, V, T, P> ) -> &mut [Option<&'a Node<'a, V, T>>; N]

where V: Variant<'a, T, Prev = NodeRefsArray<'a, N, V, T>>, P: PinnedVec<Node<'a, V, T>>,

Returns a mutable reference to previous references of the node.

pub fn next_array_mut<'rf, P, const N: usize>( &'a self, vec_mut: &SelfRefColMut<'rf, 'a, V, T, P> ) -> &mut [Option<&'a Node<'a, V, T>>; N]

where V: Variant<'a, T, Next = NodeRefsArray<'a, N, V, T>>, P: PinnedVec<Node<'a, V, T>>,

Returns a mutable reference to next references of the node.

pub fn ref_eq(&self, other: &Self) -> bool

Returns whether or not two node references are pointing to the same Node; i.e., checks referential equality.

Trait Implementations

impl<'a, V, T> Clone for Node<'a, V, T>

where V: Variant<'a, T>, V::Storage: Clone, T: Clone,

fn clone(&self) -> Self

Clones the node data without the references.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, T: Debug, V> Debug for Node<'a, V, T>

where V: Variant<'a, T>, V::Prev: Debug, V::Next: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, V, T> From<&'a Node<'a, V, T>> for NodeRefSingle<'a, V, T>

where V: Variant<'a, T>,

fn from(single_reference: &'a Node<'a, V, T>) -> Self

Converts to this type from the input type.