Struct NodeIdx 

pub struct NodeIdx<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>) -> Self

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: Variant> Clone for NodeIdx<V>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Variant> Debug for NodeIdx<V>

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

Formats the value using the given formatter.

impl<V: Variant> Hash for NodeIdx<V>

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

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<V: Variant> PartialEq for NodeIdx<V>

fn eq(&self, other: &Self) -> 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: Variant> Copy for NodeIdx<V>

impl<V: Variant> Eq for NodeIdx<V>

impl<V: Variant> Send for NodeIdx<V>

where V::Item: Send,

impl<V: Variant> Sync for NodeIdx<V>

where V::Item: Sync,