Enum Entry 

pub enum Entry<'t, 'e, P, A>
where
    P: LeafPolicy,
    A: TreeAllocator<P>,
{
    Occupied(OccupiedEntry<'t, 'e, P, A>),
    Vacant(VacantEntry<'t, 'e, P, A>),
}

A view into a single entry in a tree, which may either be vacant or occupied.

Example

use masstree::MassTree;

let tree: MassTree<u64> = MassTree::new();
let guard = tree.guard();

// Insert if absent, get value either way
let _value = tree.entry_with_guard(b"counter", &guard)
    .or_insert(0);

// Modify existing or insert default
let _value = tree.entry_with_guard(b"counter", &guard)
    .and_modify(|v| v + 1)
    .or_insert(0);

Variants

Occupied(OccupiedEntry<'t, 'e, P, A>)

An occupied entry (key exists in tree at classification time).

Vacant(VacantEntry<'t, 'e, P, A>)

A vacant entry (key does not exist classification time).

Implementations

impl<'t, 'e, P, A> Entry<'t, 'e, P, A>

where P: LeafPolicy, A: TreeAllocator<P>,

pub const fn key(&self) -> &[u8]

Returns the key for this entry.

pub fn or_insert(self, default: P::Value) -> P::Output

Fallible version or_insert.

Errors

Panics if insertion fails (allocation error). For fallible insertion, use or_try_insert.

Example

let value = tree.entry_with_guard(b"key", &guard).or_insert(42);

Returns the entry’s value if occupied, or inserts the default and returns it.

pub fn or_insert_with<F>(self, default: F) -> P::Output

where F: FnOnce() -> P::Value,

Returns the entry’s value if occupied, or computes and inserts a default.

pub fn or_insert_with_key<F>(self, default: F) -> P::Output

where F: FnOnce(&[u8]) -> P::Value,

Returns the entry’s value if occupied, or computes a default from the key.

pub fn or_default(self) -> P::Output

where P::Value: Default,

Inserts the default value if vacant, returns the entry’s value.

pub fn and_modify<F>(self, f: F) -> Self

where F: FnOnce(&P::Output) -> P::Value,

Modifies the value if occupied using the provided function.

pub fn insert_entry(self, value: P::Value) -> OccupiedEntry<'t, 'e, P, A>

Inserts a value and returns an OccupiedEntry.

pub const fn get(&self) -> Option<&P::Output>

Returns a reference to the value if occupied, or None if vacant.

Trait Implementations

impl<P, A> Debug for Entry<'_, '_, P, A>

where P: LeafPolicy, P::Output: Send + Sync + Debug, A: TreeAllocator<P>,

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

Formats the value using the given formatter.