Struct NodePtr 

pub struct NodePtr<V: Variant> { /* private fields */ }

A wrapper around a node pointer.

Implementations

impl<V: Variant> NodePtr<V>

pub fn new(ptr: *const Node<V>) -> Self

Creates a new node pointer by wrapping the given ptr.

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

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

Returns true if:

• collection owns this NodePtr, and
• the node, or corresponding element of the collection, that this pointer is pointing at is still active;

false otherwise.

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

pub unsafe fn ptr(self) -> *const Node<V>

Returns the const raw pointer to the node.

SAFETY

This method is unsafe as NodePtr 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 unsafe fn ptr_mut(self) -> *mut Node<V>

Returns the mutable raw pointer to the node.

SAFETY

This method is unsafe as NodePtr 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 unsafe fn node<'a>(self) -> &'a Node<V>

Returns a reference to the node.

Safety

It is safe to directly access the underlying node if we know that is_valid_for(col) would return true where col is the collection that this pointer is created from.

pub unsafe fn node_mut<'a>(self) -> &'a mut Node<V>

Returns a mutable reference to the node.

Safety

It is safe to directly access the underlying node if we know that is_valid_for(col) would return true where col is the collection that this pointer is created from.

Trait Implementations

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

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

Formats the value using the given formatter.

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

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

where V::Item: Send,

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

where V::Item: Sync,