Struct NodeStoreVec

pub struct NodeStoreVec<K: Key, V, A: Argument<K> = ()> { /* private fields */ }

Implementations

impl<K: Key, V, A: Argument<K>> NodeStoreVec<K, V, A>

pub fn new() -> Self

Create a new NodeStoreVec

pub fn with_capacity(cap: usize) -> Self

Create a new NodeStoreVec with capacity

Trait Implementations

impl<K: Key, V: Clone> Clone for NodeStoreVec<K, V>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug + Key, V: Debug, A: Debug + Argument<K>> Debug for NodeStoreVec<K, V, A>

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

Formats the value using the given formatter.

impl<K: Key, V, A: Argument<K>> Default for NodeStoreVec<K, V, A>

fn default() -> Self

Returns the “default value” for a type.

impl<K: Key, V, A: Argument<K>> NodeStore for NodeStoreVec<K, V, A>

type K = K

Key type for the tree

type V = V

Value type for the tree

type Argument = A

The Argument type

fn inner_n() -> u16

Get the max number of keys inner node can hold

fn leaf_n() -> u16

Get the max number of elements leaf node can hold

fn new_empty_leaf(&mut self) -> (LeafNodeId, &mut LeafNode<K, V>)

Create a new empty leaf node and returns its id

fn add_inner(&mut self, node: Box<InnerNode<K, A>>) -> InnerNodeId

Add the inner node to the store and returns its id

fn get_inner(&self, id: InnerNodeId) -> &InnerNode<K, A>

Get the inner node

fn try_get_inner(&self, id: InnerNodeId) -> Option<&InnerNode<K, A>>

Get the inner node if id is invalid or the node already removed, remove None

fn get_mut_inner(&mut self, id: InnerNodeId) -> &mut InnerNode<K, A>

Get a mut reference to the InnerNode

fn take_inner(&mut self, id: InnerNodeId) -> Box<InnerNode<K, A>>

Take the inner node out of the store

fn put_back_inner(&mut self, id: InnerNodeId, node: Box<InnerNode<K, A>>)

Put back the inner node

fn reserve_leaf(&mut self) -> LeafNodeId

Reserve a leaf node, it must be assigned later

fn get_leaf(&self, id: LeafNodeId) -> &LeafNode<Self::K, Self::V>

Get a refernce to leaf node Panics if id is invalid or the node is taken

fn try_get_leaf(&self, id: LeafNodeId) -> Option<&LeafNode<K, V>>

Get a reference to leaf node Returns None if id is invalid or the node is taken

fn get_mut_leaf(&mut self, id: LeafNodeId) -> &mut LeafNode<K, V>

Get a mut reference to leaf node Panics if id is invalid or the node is taken

fn take_leaf(&mut self, id: LeafNodeId) -> Box<LeafNode<K, V>>

Take the leaf out of store

fn assign_leaf(&mut self, id: LeafNodeId, leaf: Box<LeafNode<K, V>>)

Assign the leaf to the id, the id must exists

unsafe fn get_mut_inner_ptr(&mut self, id: InnerNodeId) -> *mut InnerNode<K, A>

Get a mut pointer to inner node. User must ensure there is non shared reference to the node co-exists

fn cache_leaf(&self, leaf_id: LeafNodeId)

cache leaf

fn try_cache<Q>(&self, k: &Q) -> Option<LeafNodeId>

where Q: Ord + ?Sized, Self::K: Borrow<Q>,

try cache for k