Struct broccoli::node::VistrMut

#[repr(transparent)]pub struct VistrMut<'a, N> { /* fields omitted */ }

Tree Iterator that returns a protected mutable reference to each node.

Implementations

impl<'a, N> VistrMut<'a, N>

pub fn new(inner: VistrMut<'a, N, PreOrder>) -> Self

pub fn borrow_mut(&mut self) -> VistrMut<'_, N>

It is safe to borrow the iterator and then produce mutable references from that as long as by the time the borrow ends, all the produced references also go away.

pub fn into_slice(self) -> PMut<'a, [N]>

Methods from Deref<Target = Vistr<'a, N>>

pub fn borrow(&self) -> Vistr<'_, T, D>

Trait Implementations

impl<'a, N> Deref for VistrMut<'a, N>

type Target = Vistr<'a, N>

The resulting type after dereferencing.

pub fn deref(&self) -> &Vistr<'a, N>

Dereferences the value.

impl<'a, N> FixedDepthVisitor for VistrMut<'a, N>

pub fn get_height(&self) -> usize

impl<'a, N> Visitor for VistrMut<'a, N>

type Item = PMut<'a, N>

The common item produced for both leafs and non leafs.

pub fn next(self) -> (Self::Item, Option<[Self; 2]>)

Consume this visitor, and produce the element it was pointing to along with it's children visitors.

pub fn level_remaining_hint(&self) -> (usize, Option<usize>)

Return the levels remaining including the one that will be produced by consuming this iterator. So if you first made this object from the root for a tree of size 5, it should return 5. Think of is as height-depth. This is used to make good allocations when doing dfs and bfs. Defaults to (0,None)

pub fn dfs_preorder(self, func: impl FnMut(Self::Item))

Calls the closure in dfs preorder (root,left,right). Takes advantage of the callstack to do dfs.

pub fn with_depth(self, start_depth: Depth) -> LevelIter<Self>

Iterator Adapter to also produce the depth each iteration.

pub fn zip<F>(self, f: F) -> Zip<Self, F> where
    F: Visitor, 

Combine two tree visitors.

pub fn map<B, F>(self, func: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> B, 

Map iterator adapter

pub fn take(self, num: usize) -> Take<Self>

Only produce children up to num.

pub fn flip(self) -> Flip<Self>

Flips left and right children.

pub fn dfs_preorder_iter(self) -> DfsPreOrderIter<Self>

Provides a dfs preorder iterator. Unlike the callback version, This one relies on dynamic allocation for its stack.

pub fn dfs_inorder_iter(self) -> DfsInOrderIter<Self>

pub fn dfs_inorder(self, func: impl FnMut(Self::Item))

Calls the closure in dfs preorder (left,right,root). Takes advantage of the callstack to do dfs.

pub fn dfs_postorder(self, func: impl FnMut(Self::Item))

Calls the closure in dfs preorder (left,right,root). Takes advantage of the callstack to do dfs.