Struct VacantEntry 

pub struct VacantEntry<'a, P, Tag, K>
where
    P: Pointer,
    P::Target: AvlItem<Tag>,
{ /* private fields */ }

Examples

use embed_avl::{AvlTree, AvlItem, AvlNode, Entry};
use core::cell::UnsafeCell;
use core::borrow::Borrow;
extern crate alloc;
use alloc::sync::Arc;

struct MyNode {
    value: i32,
    avl_node: UnsafeCell<AvlNode<MyNode, ()>>,
}

unsafe impl AvlItem<()> for MyNode {

    fn get_node(&self) -> &mut AvlNode<MyNode, ()> {
        unsafe { &mut *self.avl_node.get() }
    }
}
impl Borrow<i32> for MyNode {
    fn borrow(&self) -> &i32 {
        &self.value
    }
}

let mut tree = AvlTree::<Arc<MyNode>, ()>::new();
let key = 42;
if let Entry::Vacant(ent) = tree.entry(key) {
    ent.insert_node(Arc::new(MyNode {
        value: key,
        avl_node: UnsafeCell::new(Default::default()),
    }));
}

Implementations

impl<'a, P, Tag, K> VacantEntry<'a, P, Tag, K>

where P: Pointer, P::Target: AvlItem<Tag>,

pub fn nearest(&self) -> Option<&P::Target>

Return the nearest node in the search result

pub fn peek_prev(&self) -> Option<&P::Target>

pub fn key(&self) -> &K

pub fn peek_next(&self) -> Option<&P::Target>

pub fn move_prev(self) -> Option<OccupiedEntry<'a, P, Tag>>

pub fn move_next(self) -> Option<OccupiedEntry<'a, P, Tag>>

pub unsafe fn insert_node_unchecked( self, new_node: P, ) -> OccupiedEntry<'a, P, Tag>

Safety

Caller should make sure new_node have the same value to the search key to entry(),

ignoring K captured in VacantEntry

impl<'a, P, Tag, K> VacantEntry<'a, P, Tag, K>

where P: Pointer, P::Target: AvlItem<Tag> + Borrow<K>, K: PartialEq,

pub fn insert_node(self, new_node: P) -> OccupiedEntry<'a, P, Tag>

insert new_node at the position, for entry search by borrowed key

Safety

We have debug_assert_eq the key an the node