Struct WalkMutBorrowed

pub struct WalkMutBorrowed<'r, TP: TreeProperties + 'r, D = (), A = ()> { /* private fields */ }

Walk borrowed mutable tree up and down

Some algorithms need to remember how they reached the current node via WalkedDirection as D.

When walking manually it might be useful to be able to store additional data via A.

Implementations

impl<'r, TP, D, A> WalkMutBorrowed<'r, TP, D, A>

where TP: TreeProperties,

pub fn up(&mut self) -> Option<D>

Walk up to parent node or tree if not at tree

pub fn up_with(&mut self) -> Option<(D, A)>

Walk up to parent node or tree if not at tree

pub fn current(&self) -> NodeOrTree<Option<&Node<TP>>, &Node<TP>>

Current node or tree

pub fn current_mut( &mut self, ) -> NodeOrTree<Option<&mut Node<TP>>, &mut Node<TP>>

Current mutable node or tree

If you need the result to outlive the destruction of the WalkMutBorrowed value, see into_current_mut.

pub fn into_current_mut( self, ) -> NodeOrTree<Option<&'r mut Node<TP>>, &'r mut Node<TP>>

Extract mutable node or tree

Also see current_mut

impl<'r, TP, D, A> WalkMutBorrowed<'r, TP, D, A>

where TP: TreeProperties + 'r, D: From<WalkedDirection>,

pub fn down_root_with(&mut self, add: A) -> bool

Walk down from tree to root node (if at tree and not empty)

pub fn down_left_with(&mut self, add: A) -> bool

Walk down to left node if present and not currently at tree

pub fn down_right_with(&mut self, add: A) -> bool

Walk down to right node if present and not currently at tree

pub fn down_with(&mut self, side: bool, add: A) -> bool

Walk down to specified node if present and not currently at tree

false picks left and true picks right.

impl<'r, TP, D> WalkMutBorrowed<'r, TP, D, ()>

where TP: TreeProperties + 'r, D: From<WalkedDirection>,

pub fn down_root(&mut self) -> bool

Walk down from tree to root node (if at tree and not empty)

pub fn down_left(&mut self) -> bool

Walk down to left node if present and not currently at tree

pub fn down_right(&mut self) -> bool

Walk down to right node if present and not currently at tree

pub fn down(&mut self, side: bool) -> bool

Walk down to specified node if present and not currently at tree

false picks left and true picks right.

impl<'r, TP, D> WalkMutBorrowed<'r, TP, D>

where TP: TreeProperties + 'r, D: From<WalkedDirection>,

pub fn path(&mut self, key: TP::Key) -> WalkMutBorrowedPath<'r, '_, TP, D>

Start iterator to walk to deepest node that is a prefix of the target key

While consuming the iterator the stack is updated with the position of the returned nodes.

When self was in a mismatching subtree (i.e. not a prefix of the target key) before the iterator won’t find anything.

pub fn goto_insert(&mut self, key: &TP::Key) -> Option<InsertPosition>

Walk to node where we’d have to insert key at

Returns None if tree is empty.

impl<'r, TP> WalkMutBorrowed<'r, TP, WalkedDirection, ()>

where TP: TreeProperties + 'r,

pub fn into_iter_pre_order(self) -> IterMutBorrowedPreOrder<'r, TP>

Convert into iterator traversing depth-first pre-order

pub fn next_pre_order(&mut self) -> Option<&mut Node<TP>>

Tree traversal: depth-first pre-order

pub fn into_iter_in_order(self) -> IterMutBorrowedInOrder<'r, TP>

Convert into iterator traversing depth-first in-order

pub fn next_in_order(&mut self) -> Option<&mut Node<TP>>

Tree traversal: depth-first in-order

pub fn into_iter_post_order(self) -> IterMutBorrowedPostOrder<'r, TP>

Convert into iterator traversing depth-first post-order

pub fn next_post_order(&mut self) -> Option<&mut Node<TP>>

Tree traversal: depth-first post-order

pub fn into_iter_leafs(self) -> IterMutBorrowedLeaf<'r, TP>

Convert into iterator over all leafs

pub fn into_iter_full_leafs(self) -> IterMutBorrowedLeafFull<'r, TP>

Convert into iterator over all leafs and uncovered parts

pub fn next_leaf(&mut self) -> Option<&mut Node<TP>>

Tree traversal: depth-first in-order leaf nodes only