Struct NodeIdx

pub struct NodeIdx<V>
where
    V: Variant,
{ /* private fields */ }

A node index providing safe and constant time access to elements of the self referential collection.

Implementations

impl<V> NodeIdx<V>

where V: Variant,

pub fn new(state: MemoryState, node_ptr: &NodePtr<V>) -> NodeIdx<V>

Creates a new index for the element at the given node_ptr and the collection with the given state.

pub fn is_in_state(&self, state: MemoryState) -> bool

Checks whether or not the state of the index matches that of this index.

pub fn get_ptr(&self, collection_state: MemoryState) -> Option<*mut Node<V>>

Returns the node pointer if the index is in the same state as the collection_state, None otherwise.

pub fn node_ptr(&self) -> NodePtr<V>

Converts the node index into a node pointer.

pub fn is_valid_for<M, P>(&self, collection: &SelfRefCol<V, M, P>) -> bool

where M: MemoryPolicy<V>, P: PinnedVec<Node<V>>,

Returns true only if this index is valid for the given collection.

A node index is valid iff it satisfies the following two conditions:

• It is created from the given collection.
• Memory state of the collection has not changed since this index was created.

Trait Implementations

impl<V> Clone for NodeIdx<V>

where V: Variant,

fn clone(&self) -> NodeIdx<V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V> Debug for NodeIdx<V>

where V: Variant,

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

Formats the value using the given formatter.

impl<'i, T, M, P> Index<&'i NodeIdx<Doubly<T>>> for List<Doubly<T>, M, P>

where M: MemoryPolicy<Doubly<T>>, P: PinnedVec<Node<Doubly<T>>>,

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.

type Output = T

The returned type after indexing.

impl<'i, T, M, P> Index<&'i NodeIdx<Doubly<T>>> for ListSlice<'_, Doubly<T>, M, P>

where M: MemoryPolicy<Doubly<T>>, P: PinnedVec<Node<Doubly<T>>>,

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.

type Output = T

The returned type after indexing.

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>>>,

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.

type Output = T

The returned type after indexing.

impl<'i, T, M, P> Index<&'i NodeIdx<Singly<T>>> for List<Singly<T>, M, P>

where M: MemoryPolicy<Singly<T>>, P: PinnedVec<Node<Singly<T>>>,

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.

type Output = T

The returned type after indexing.

impl<'i, T, M, P> Index<&'i NodeIdx<Singly<T>>> for ListSlice<'_, Singly<T>, M, P>

where M: MemoryPolicy<Singly<T>>, P: PinnedVec<Node<Singly<T>>>,

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.

type Output = T

The returned type after indexing.

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>>>,

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.

type Output = T

The returned type after indexing.

impl<'i, T, M, P> IndexMut<&'i NodeIdx<Doubly<T>>> for List<Doubly<T>, M, P>

where M: MemoryPolicy<Doubly<T>>, P: PinnedVec<Node<Doubly<T>>>,

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.

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>>>,

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.

impl<'i, T, M, P> IndexMut<&'i NodeIdx<Singly<T>>> for List<Singly<T>, M, P>

where M: MemoryPolicy<Singly<T>>, P: PinnedVec<Node<Singly<T>>>,

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.

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>>>,

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.

impl<V> PartialEq for NodeIdx<V>

where V: Variant,

fn eq(&self, other: &NodeIdx<V>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> Copy for NodeIdx<V>

where V: Copy + Variant,

impl<V> Eq for NodeIdx<V>

where V: Variant,