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 unsafe 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.

SAFETY

This method is unsafe as NodeIdx implements Send and Sync.

It is safe dereference the received pointer if we know that is_valid_for(col) would return true where col is the collection that this pointer is created from.

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.

It is safe to use the unsafe methods of NodeIdx if is_valid_for(col) returns true where col is the collection that the index is created from.

pub fn node<M, P>(self, collection: &SelfRefCol<V, M, P>) -> Option<&Node<V>>

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

Returns a reference to the node that this NodeIdx corresponds to; returns None if the index is invalid.

See Self::is_valid_for for validity conditions.

Trait Implementations

impl<V> Clone for NodeIdx<V>

where V: Variant,

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

Returns a duplicate 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<V> Hash for NodeIdx<V>

where V: Variant,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

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

fn index(&self, index: 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<T, M, P> Index<NodeIdx<Doubly<T>>> for ListSlice<'_, Doubly<T>, M, P>

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

fn index(&self, index: 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<T, M, P> Index<NodeIdx<Doubly<T>>> for ListSliceMut<'_, Doubly<T>, M, P>

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

fn index(&self, index: 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<T, M, P> Index<NodeIdx<Singly<T>>> for List<Singly<T>, M, P>

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

fn index(&self, index: 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<T, M, P> Index<NodeIdx<Singly<T>>> for ListSlice<'_, Singly<T>, M, P>

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

fn index(&self, index: 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<T, M, P> Index<NodeIdx<Singly<T>>> for ListSliceMut<'_, Singly<T>, M, P>

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

fn index(&self, index: 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<T, M, P> IndexMut<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: 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<T, M, P> IndexMut<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: 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<T, M, P> IndexMut<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: 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<T, M, P> IndexMut<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: 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: Variant,

impl<V> Eq for NodeIdx<V>

where V: Variant,

impl<V> Send for NodeIdx<V>

where V: Variant, <V as Variant>::Item: Send,

impl<V> Sync for NodeIdx<V>

where V: Variant, <V as Variant>::Item: Sync,