Struct blart::OpaqueNodePtr

#[repr(transparent)]
pub struct OpaqueNodePtr<K, V>(TaggedPointer<OpaqueValue, 3>, PhantomData<(K, V)>);

An opaque pointer to a Node.

Could be any one of the NodeTypes, need to perform check on the runtime type and then cast to a NodePtr.

Tuple Fields

0: TaggedPointer<OpaqueValue, 3>

1: PhantomData<(K, V)>

Implementations

impl<K, V> OpaqueNodePtr<K, V>

pub fn new<N>(pointer: NonNull<N>) -> Selfwhere N: Node<Value = V>,

Construct a new opaque node pointer from an existing non-null node pointer.

pub fn is<N: Node>(&self) -> bool

Return true if this Node_ pointer points to the specified concrete NodeType.

pub fn cast<N: Node>(self) -> Option<NodePtr<N>>

Create a non-opaque node pointer that will eliminate future type assertions, if the type of the pointed node matches the given node type.

pub fn to_node_ptr(self) -> ConcreteNodePtr<K, V>

Cast this opaque pointer type an enum that contains a pointer to the concrete node type.

pub fn node_type(self) -> NodeType

Retrieve the runtime node type information.

pub(crate) unsafe fn header_mut<'h>(self) -> Option<&'h mut Header>

Get a mutable reference to the header if the underlying node has a header field, otherwise return None.

Safety

• You must enforce Rust’s aliasing rules, since the returned lifetime ’h 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 accessed (read or written) through any other pointer.

Trait Implementations

impl<K, V> Clone for OpaqueNodePtr<K, V>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V> Debug for OpaqueNodePtr<K, V>

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

Formats the value using the given formatter.

impl<K, V> Hash for OpaqueNodePtr<K, 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<K, V> PartialEq<OpaqueNodePtr<K, V>> for OpaqueNodePtr<K, V>

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<K, V> Pointer for OpaqueNodePtr<K, V>

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

Formats the value using the given formatter.

impl<K, T> Visitable<K, T> for OpaqueNodePtr<K, T>

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<K, V> Copy for OpaqueNodePtr<K, V>

impl<K, V> Eq for OpaqueNodePtr<K, V>