Struct Node 

pub struct Node<V> { /* private fields */ }

A node which represents a subtree of a patricia tree.

Note that this is a low level building block. Usually it is recommended to use more high level data structures (e.g., PatriciaTree).

Implementations

impl<V> Node<V>

pub fn root() -> Self

Makes a new node which represents an empty tree.

pub fn label(&self) -> &[u8]

Returns the label of this node.

pub fn children(&self) -> &[Node<V>]

get all children for node as slice

pub fn take_children(&mut self) -> Option<Vec<Node<V>>>

take all the children out of a node and return them

pub fn children_len(&self) -> usize

return number of children

pub fn iter(&self) -> Iter<'_, V>

Gets an iterator which traverses the nodes in this tree, in depth first order.

pub fn iter_mut(&mut self) -> IterMut<'_, V>

Gets a mutable iterator which traverses the nodes in this tree, in depth first order.

pub fn iter_bfs(&self) -> IterBfs<'_, V>

Gets an iterator which traverses the nodes in this tree, in breadth first order.

pub fn iter_mut_bfs(&mut self) -> IterMutBfs<'_, V>

Gets a mutable iterator which traverses the nodes in this tree, in breadth first order.

pub fn split_by_prefix<K: ?Sized + BorrowedBytes>( &mut self, key: &K, ) -> Option<Self>

split the node by the prefix into two distinct nodes

pub fn remove<K: ?Sized + BorrowedBytes>(&mut self, key: &K) -> Option<V>

remove the value at key and return it, merging the tree with its children if necessary.

pub fn try_merge_child(&mut self)

merge child if we only have one child

pub fn entry<K>(&mut self, key: &K) -> Entry<'_, V>

where K: ?Sized + BorrowedBytes,

entry api for node

pub fn insert<K: ?Sized + BorrowedBytes>( &mut self, key: &K, value: V, ) -> Option<V>

insert key and value into node, replacing value if key exists could be re-written to use Entry but the non-entry version is 5-10% faster so I’m leaving this for now SAFETY: caller must not insert an empty label into children. only the root node can have an empty label

pub fn label_len(&self) -> usize

return node label length

pub fn into_iter_bfs(self) -> IntoIterBfs<V>

construct into_iter iterates breadth first search style

impl<V> Node<V>

pub fn new<const N: usize>( label: &[u8], children: [Node<V>; N], value: Option<V>, ) -> Self

Makes a new node. SAFETY: - label len must not exceed 255 - children len must not exceed 255

pub fn value(&self) -> Option<&V>

Returns the reference to the value of this node.

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

Returns the mutable reference to the value of this node.

pub fn as_mut(&mut self) -> NodeMut<'_, V>

Returns mutable references to the node itself with its sibling and child

pub fn take_value(&mut self) -> Option<V>

Takes the value out of this node.

pub fn prefix_label(&mut self, prefix: &[u8])

set label with prefix slice NOTE: you can seriously mess up a node calling these functions manually

pub fn replace_label(&mut self, prefix: &[u8])

swap label with new one (will realloc node) NOTE: you can seriously mess up a node calling these functions manually

pub fn set_value(&mut self, value: V)

Sets the value of this node.

Trait Implementations

impl<V: Clone> Clone for Node<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: Debug> Debug for Node<V>

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

Formats the value using the given formatter.

impl<V> Drop for Node<V>

fn drop(&mut self)

Executes the destructor for this type.

impl<V> IntoIterator for Node<V>

type Item = (usize, Node<V>)

The type of the elements being iterated over.

type IntoIter = IntoIter<V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V: PartialEq> PartialEq for Node<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: Eq> Eq for Node<V>

impl<V: Send> Send for Node<V>

impl<V: Sync> Sync for Node<V>