Struct dinotree::VistrMut

pub struct VistrMut<'a, T: HasAabb> { /* fields omitted */ }

Tree Iterator that returns a reference to each node. It also returns the non-leaf specific data when it applies.

Methods

impl<'a, T: HasAabb> VistrMut<'a, T>

pub fn create_wrap_mut(&mut self) -> VistrMut<T>

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 height(&self) -> usize

pub fn get_nodes_mut(&mut self) -> &mut [Node<T>]

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

pub fn create_wrap(&self) -> Vistr<T>

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 height(&self) -> usize

pub fn get_nodes(&self) -> &[Node<T>]

Trait Implementations

impl<'a, T: HasAabb> Deref for VistrMut<'a, T>

type Target = Vistr<'a, T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a, T: HasAabb> Visitor for VistrMut<'a, T>

type Item = NodeRefMut<'a, T>

The common item produced for both leafs and non leafs.

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.

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)

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.

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

Iterator Adapter to also produce the depth each iteration.

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

Combine two tree visitors.

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

Map iterator adapter

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

Only produce children up to num.

fn flip(self) -> Flip<Self>

Flips left and right children.

Important traits for BfsIter<C>

impl<C> Iterator for BfsIter<C> where
    C: Visitor,  type Item = <C as Visitor>::Item;

fn bfs_iter(self) -> BfsIter<Self>

Provides an iterator that returns each element in bfs order.

Important traits for DfsPreOrderIter<C>

impl<C> Iterator for DfsPreOrderIter<C> where
    C: Visitor,  type Item = <C as Visitor>::Item;

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.

Important traits for DfsInOrderIter<C>

impl<C> Iterator for DfsInOrderIter<C> where
    C: Visitor,  type Item = <C as Visitor>::Item;

fn dfs_inorder_iter(self) -> DfsInOrderIter<Self>

fn dfs_inorder<impl FnMut(Self::Item)>(self, func: impl FnMut(Self::Item)) where     impl FnMut(Self::Item): FnMut(Self::Item),

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

fn dfs_postorder<impl FnMut(Self::Item)>(self, func: impl FnMut(Self::Item)) where     impl FnMut(Self::Item): FnMut(Self::Item),

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

impl<'a, T: HasAabb> FixedDepthVisitor for VistrMut<'a, T>