Trait NodeStore

pub trait NodeStore: Default {
    type K: Key;
    type V;
    type Argument: Argument<Self::K>;

    // Required methods
    fn inner_n() -> u16;
    fn leaf_n() -> u16;
    fn add_inner(
        &mut self,
        node: Box<InnerNode<Self::K, Self::Argument>>,
    ) -> InnerNodeId;
    fn get_inner(&self, id: InnerNodeId) -> &InnerNode<Self::K, Self::Argument>;
    fn try_get_inner(
        &self,
        id: InnerNodeId,
    ) -> Option<&InnerNode<Self::K, Self::Argument>>;
    fn get_mut_inner(
        &mut self,
        id: InnerNodeId,
    ) -> &mut InnerNode<Self::K, Self::Argument>;
    unsafe fn get_mut_inner_ptr(
        &mut self,
        id: InnerNodeId,
    ) -> *mut InnerNode<Self::K, Self::Argument>;
    fn take_inner(
        &mut self,
        id: InnerNodeId,
    ) -> Box<InnerNode<Self::K, Self::Argument>>;
    fn put_back_inner(
        &mut self,
        id: InnerNodeId,
        node: Box<InnerNode<Self::K, Self::Argument>>,
    );
    fn new_empty_leaf(
        &mut self,
    ) -> (LeafNodeId, &mut LeafNode<Self::K, Self::V>);
    fn reserve_leaf(&mut self) -> LeafNodeId;
    fn get_leaf(&self, id: LeafNodeId) -> &LeafNode<Self::K, Self::V>;
    fn try_get_leaf(
        &self,
        id: LeafNodeId,
    ) -> Option<&LeafNode<Self::K, Self::V>>;
    fn get_mut_leaf(
        &mut self,
        id: LeafNodeId,
    ) -> &mut LeafNode<Self::K, Self::V>;
    fn take_leaf(&mut self, id: LeafNodeId) -> Box<LeafNode<Self::K, Self::V>>;
    fn assign_leaf(
        &mut self,
        id: LeafNodeId,
        leaf: Box<LeafNode<Self::K, Self::V>>,
    );
    fn cache_leaf(&self, leaf_id: LeafNodeId);
    fn try_cache<Q>(&self, k: &Q) -> Option<LeafNodeId>
       where Q: Ord + ?Sized,
             Self::K: Borrow<Q>;
}

NodeStore is the node storage for tree, responsible for define node types, manage node memory, and provide node access

Required Associated Types

type K: Key

Key type for the tree

type V

Value type for the tree

type Argument: Argument<Self::K>

The Argument type

Required Methods

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 add_inner( &mut self, node: Box<InnerNode<Self::K, Self::Argument>>, ) -> InnerNodeId

Add the inner node to the store and returns its id

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

Get the inner node

Panics

if id is invalid or the node is already removed, panic

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

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<Self::K, Self::Argument>

Get a mut reference to the InnerNode

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

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

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

Take the inner node out of the store

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

Put back the inner node

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

Create a new empty leaf node and returns its id

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<Self::K, Self::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<Self::K, Self::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<Self::K, Self::V>>

Take the leaf out of store

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

Assign the leaf to the id, the id must 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

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

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

type K = K

type V = V

type Argument = A