Struct blart::NodePtr

#[repr(transparent)]
pub struct NodePtr<N: Node>(NonNull<N>);

A pointer to a Node.

Tuple Fields

0: NonNull<N>

Implementations

impl<N: Node> NodePtr<N>

pub unsafe fn new(ptr: *mut N) -> Self

Create a safe pointer to a Node.

Safety

Given pointer must be non-null, aligned, and valid for reads or writes of a value of N type.

pub fn allocate_node_ptr(node: N) -> Self

Allocate the given Node on the std::alloc::Global heap and return a NodePtr that wrap the raw pointer.

pub unsafe fn deallocate_node_ptr(node: Self) -> N

Deallocate a Node object created with the NodePtr::allocate_node_ptr function.

Safety

• This function can only be called once for a given node object.

pub unsafe fn replace(dest: Self, new_value: N) -> N

Moves new_value into the referenced dest, returning the previous dest value.

Neither value is dropped.

Safety

• The node the dest pointers points to must not get accessed (read or written) through any other pointers concurrent to this modification.

pub fn to_opaque(self) -> OpaqueNodePtr<N::Key, N::Value>

Cast node pointer back to an opaque version, losing type information

pub fn read(self) -> ManuallyDrop<N>

Reads the Node from self without moving it. This leaves the memory in self unchanged.

pub unsafe fn as_ref<'a>(self) -> &'a N

Returns a shared reference to the value.

Safety

• You must enforce Rust’s aliasing rules, since the returned lifetime ’a is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, for the duration of this lifetime, the memory the pointer points to must not get mutated (except inside UnsafeCell).

pub unsafe fn as_mut<'a>(self) -> &'a mut N

Returns a unique mutable reference to the node.

Safety

• You must enforce Rust’s aliasing rules, since the returned lifetime ’a is arbitrarily chosen and does not necessarily reflect the actual lifetime of the node. In particular, for the duration of this lifetime, the node the pointer points to must not get accessed (read or written) through any other pointer.

pub fn to_ptr(self) -> *mut N

Acquires the underlying *mut pointer.

impl<K, V> NodePtr<LeafNode<K, V>>

pub unsafe fn as_key_value_ref<'a>(self) -> (&'a K, &'a V)

Returns a shared reference to the key and value of the pointed to LeafNode.

Safety

• You must enforce Rust’s aliasing rules, since the returned lifetime ’a is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, for the duration of this lifetime, the memory the pointer points to must not get mutated (except inside UnsafeCell).

pub unsafe fn as_key_ref_value_mut<'a>(self) -> (&'a K, &'a mut V)

Returns a unique mutable reference to the key and value of the pointed to LeafNode.

Safety

• You must enforce Rust’s aliasing rules, since the returned lifetime ’a is arbitrarily chosen and does not necessarily reflect the actual lifetime of the node. In particular, for the duration of this lifetime, the node the pointer points to must not get accessed (read or written) through any other pointer.

pub unsafe fn as_key_ref<'a>(self) -> &'a Kwhere V: 'a,

Returns a unique mutable reference to the key and value of the pointed to LeafNode.

Safety

• You must enforce Rust’s aliasing rules, since the returned lifetime ’a is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, for the duration of this lifetime, the memory the pointer points to must not get mutated (except inside UnsafeCell).

pub unsafe fn as_value_ref<'a>(self) -> &'a Vwhere K: 'a, V: 'a,

Returns a unique mutable reference to the key and value of the pointed to LeafNode.

Safety

• You must enforce Rust’s aliasing rules, since the returned lifetime ’a is arbitrarily chosen and does not necessarily reflect the actual lifetime of the data. In particular, for the duration of this lifetime, the memory the pointer points to must not get mutated (except inside UnsafeCell).

pub unsafe fn as_value_mut<'a>(self) -> &'a mut Vwhere K: 'a, V: 'a,

Returns a unique mutable reference to the key and value of the pointed to LeafNode.

Safety

• You must enforce Rust’s aliasing rules, since the returned lifetime ’a is arbitrarily chosen and does not necessarily reflect the actual lifetime of the node. In particular, for the duration of this lifetime, the node the pointer points to must not get accessed (read or written) through any other pointer.

Trait Implementations

impl<N: Node> Clone for NodePtr<N>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Node> Debug for NodePtr<N>

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

Formats the value using the given formatter.

impl<N: Node> From<&mut N> for NodePtr<N>

fn from(node_ref: &mut N) -> Self

Converts to this type from the input type.

impl<N: Node> PartialEq<NodePtr<N>> for NodePtr<N>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<N: Node> Pointer for NodePtr<N>

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

Formats the value using the given formatter.

impl<K, T, N: Node + Visitable<K, T>> Visitable<K, T> for NodePtr<N>

fn super_visit_with<V: Visitor<K, T>>(&self, visitor: &mut V) -> V::Output

This function provides the default traversal behavior for the implementing type.

fn visit_with<V: Visitor<K, T>>(&self, visitor: &mut V) -> V::Output

This function will traverse the implementing type and execute any specific logic from the given Visitor.

impl<N: Node> Copy for NodePtr<N>

impl<N: Node> Eq for NodePtr<N>