Struct blart::nodes::representation::InnerNode48

pub struct InnerNode48<K, V> {
    pub header: Header,
    pub child_indices: [RestrictedNodeIndex<48>; 256],
    pub child_pointers: [MaybeUninit<OpaqueNodePtr<K, V>>; 48],
}

Node that references between 17 and 49 children

Fields

header: Header

The common node fields.

child_indices: [RestrictedNodeIndex<48>; 256]

An array that maps key bytes (as the index) to the index value in the child_pointers array.

All the child_indices values are guaranteed to be PartialNodeIndex<48>::EMPTY when the node is constructed.

child_pointers: [MaybeUninit<OpaqueNodePtr<K, V>>; 48]

For each element in this array, it is assumed to be initialized if there is a index in the child_indices array that points to it

Implementations

impl<K, V> InnerNode48<K, V>

pub fn empty() -> Self

Create an empty Node48.

pub fn initialized_child_pointers(&self) -> &[OpaqueNodePtr<K, V>]

Return the initialized portions of the child pointer array.

Trait Implementations

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

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

Formats the value using the given formatter.

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

type GrownNode = InnerNode256<<InnerNode48<K, V> as Node>::Key, <InnerNode48<K, V> as Node>::Value>

The type of the next larger node type.

type Iter = InnerNode48Iter<<InnerNode48<K, V> as Node>::Key, <InnerNode48<K, V> as Node>::Value>

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

type ShrunkNode = InnerNodeCompressed<<InnerNode48<K, V> as Node>::Key, <InnerNode48<K, V> as Node>::Value, 16>

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 InnerNode48<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::Node48

The runtime type of the node.

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