Struct blart::nodes::representation::InnerNode256

pub struct InnerNode256<K, V> {
    pub header: Header,
    pub child_pointers: [Option<OpaqueNodePtr<K, V>>; 256],
}

Node that references between 49 and 256 children

Fields

header: Header

The common node fields.

child_pointers: [Option<OpaqueNodePtr<K, V>>; 256]

An array that directly maps a key byte (as index) to a child node.

Implementations

impl<K, V> InnerNode256<K, V>

pub fn empty() -> Self

Create an empty InnerNode256.

Trait Implementations

impl<K, V> Clone for InnerNode256<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 InnerNode256<K, V>

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

Formats the value using the given formatter.

impl<K, V> InnerNode for InnerNode256<K, V>

type GrownNode = InnerNode256<K, V>

The type of the next larger node type.

type Iter = InnerNode256Iter<K, V>

The type of the iterator over all children of the inner node

type ShrunkNode = InnerNode48<K, V>

The type of the next smaller node type.

fn lookup_child( &self, key_fragment: u8 ) -> Option<OpaqueNodePtr<<Self as Node>::Key, <Self as Node>::Value>>

Search through this node for a child node that corresponds to the given key fragment.

fn write_child( &mut self, key_fragment: u8, child_pointer: OpaqueNodePtr<<Self as Node>::Key, <Self as Node>::Value> )

Write a child pointer with key fragment to this inner node.

fn remove_child( &mut self, key_fragment: u8 ) -> Option<OpaqueNodePtr<<Self as Node>::Key, <Self as Node>::Value>>

Attempt to remove a child pointer at the key fragment from this inner node.

fn grow(&self) -> Self::GrownNode

Grow this node into the next larger class, copying over children and prefix information.

fn shrink(&self) -> Self::ShrunkNode

Shrink this node into the next smaller class, copying over children and prefix information.

fn header(&self) -> &Header

Access the header information for this node.

fn header_mut(&mut self) -> &mut Header

Access the header information for this node.

unsafe fn iter(&self) -> Self::Iter

Create an iterator over all (key bytes, child pointers) in this inner node.

fn split_at(&mut self, key_fragment: u8) -> Self

Split the inner node at the given key-byte, returning a new InnerNode of the same type that contains all children including and after the given key fragment. The original inner node has those children removed.

fn num_children_after_split(&self, key_fragment: u8) -> (usize, usize)

This function will count the number of children before and after the split point.

fn is_full(&self) -> bool

Returns true if this node has no more space to store children.

impl<K, V> Node for InnerNode256<K, V>

type Key = K

The key type carried by the leafe nodes

type Value = V

The value type carried by the leaf nodes

const TYPE: NodeType = NodeType::Node256

The runtime type of the node.

impl<K, T> Visitable<K, T> for InnerNode256<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> Sealed for InnerNode256<K, V>