Struct OccupiedEntry 

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

Implementations

impl<'a, P, Tag> OccupiedEntry<'a, P, Tag>

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

pub fn get(&self) -> &'a P::Target

pub fn clone_ref(&self) -> P

where P: CloneablePointer,

pub fn remove(self) -> P

Remove the node from the tree

pub fn remove_prev(&mut self) -> Option<P>

Remove the next node if it exists and return the reference, without changing the current position.

pub fn remove_next(&mut self) -> Option<P>

Remove the next node if it exists and return the reference, without changing the current position.

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

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

pub fn move_prev(self) -> Option<Self>

pub fn move_next(self) -> Option<Self>

pub unsafe fn insert_prev_unchecked(&mut self, new_node: P)

Insert before the current node. The entry position is unchanged.

Safety

Caller should make sure the new_node is exactly before the current node.

otherwise the new_node is way smaller than its ancestor (with value not adjacent to current node) will break the tree total ordering.

pub unsafe fn insert_move_prev_unchecked(self, new_node: P) -> Self

Insert before the current node, with entry position is changed to newly inserted node.

Safety

Caller should make sure the new_node is exactly before the current node.

otherwise the new_node is way smaller than its ancestor (with value not adjacent to current node) will break the tree total ordering.

pub unsafe fn insert_next_unchecked(&mut self, new_node: P)

Insert after the current node. The entry position is unchanged.

Safety

Caller should make sure the new_node is exactly after the current node.

Otherwise the new_node is way smaller than its ancestor (with value not adjacent to current node) will break the tree total ordering.

pub unsafe fn insert_move_next_unchecked(self, new_node: P) -> Self

Insert after the current node, with entry position is changed to newly inserted node.

Safety

Caller should make sure the new_node is exactly after the current node.

Otherwise the new_node is way smaller than its ancestor (with value not adjacent to current node) will break the tree total ordering.

Trait Implementations

impl<'a, P, Tag> AsRef<<P as Pointer>::Target> for OccupiedEntry<'a, P, Tag>

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

fn as_ref(&self) -> &P::Target

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, P, Tag> Deref for OccupiedEntry<'a, P, Tag>

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

type Target = <P as Pointer>::Target

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.