Struct LeafNode

#[repr(align(8))]
pub struct LeafNode<K, V, const PREFIX_LEN: usize> { /* private fields */ }

Node that contains a single leaf value.

Implementations

impl<K, V, const PREFIX_LEN: usize> LeafNode<K, V, PREFIX_LEN>

where K: AsBytes,

pub unsafe fn insert_after( this_ptr: NodePtr<PREFIX_LEN, Self>, previous_sibling_ptr: NodePtr<PREFIX_LEN, Self>, )

Insert the leaf node pointed to by this_ptr into the linked list that previous_sibling_ptr belongs to, placing the “this” leaf node after the “previous sibling” in the list.

Safety

This function requires that no other operation is concurrently modifying or reading the this_ptr leaf node, the previous_sibling_ptr leaf node, and the sibling leaf node of previous_sibling_ptr.

pub unsafe fn insert_before( this_ptr: NodePtr<PREFIX_LEN, Self>, next_sibling_ptr: NodePtr<PREFIX_LEN, Self>, )

Insert the leaf node pointed to by this_ptr into the linked list that next_sibling_ptr belongs to, placing the “this” leaf node before the “next sibling” in the list.

Safety

This function requires that no other operation is concurrently modifying or reading the this_ptr leaf node, the next_sibling_ptr leaf node, and the sibling leaf node of next_sibling_ptr.

pub unsafe fn replace(this_ptr: NodePtr<PREFIX_LEN, Self>, old_leaf: &mut Self)

Insert the leaf node pointed to by this_ptr into the linked list position that old_leaf currently occupies, and then remove old_leaf from the linked list.

Safety

This function requires that no other operation is concurrently modifying or reading the this_ptr leaf node and the sibling leaf nodes of the old_leaf.

impl<const PREFIX_LEN: usize, K, V> LeafNode<K, V, PREFIX_LEN>

pub fn with_no_siblings(key: K, value: V) -> Self

Create a new leaf node with the given value and no siblings.

pub fn key_ref(&self) -> &K

Returns a shared reference to the key contained by this leaf node

pub fn value_ref(&self) -> &V

Returns a shared reference to the value contained by this leaf node

pub fn value_mut(&mut self) -> &mut V

Returns a mutable reference to the value contained by this leaf node

pub fn entry_ref(&self) -> (&K, &V)

Return shared references to the key and value contained by this leaf node

pub fn entry_mut(&mut self) -> (&mut K, &mut V)

Return mutable references to the key and value contained by this leaf node

pub fn into_entry(self) -> (K, V)

Consume the leaf node and return a tuple of the key and value

pub fn matches_full_key(&self, possible_key: &[u8]) -> bool

where K: AsBytes,

Check that the provided full key is the same one as the stored key.

pub unsafe fn remove_self(this_ptr: NodePtr<PREFIX_LEN, Self>)

This function removes this leaf node from its linked list.

Safety

This function requires that no other operation is concurrently modifying or reading the this_ptr leaf node and its sibling leaf nodes.

pub fn clone_without_siblings(&self) -> Self

where K: Clone, V: Clone,

Create a copy of this leaf node with the sibling references removed.

Trait Implementations

impl<K: Debug, V: Debug, const PREFIX_LEN: usize> Debug for LeafNode<K, V, PREFIX_LEN>

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

Formats the value using the given formatter.

impl<const PREFIX_LEN: usize, K, V> Node<PREFIX_LEN> for LeafNode<K, V, PREFIX_LEN>

const TYPE: NodeType = NodeType::Leaf

The runtime type of the node.

type Key = K

The key type carried by the leaf nodes

type Value = V

The value type carried by the leaf nodes

impl<K, T, const PREFIX_LEN: usize> Visitable<K, T, PREFIX_LEN> for LeafNode<K, T, PREFIX_LEN>

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

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

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

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