Trait Visitor 

pub trait Visitor: Sized {
    type Item;

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

    // Provided methods
    fn level_remaining_hint(&self) -> (usize, Option<usize>) { ... }
    fn with_depth(self, start_depth: Depth) -> LevelIter<Self> { ... }
    fn zip<F: Visitor>(self, f: F) -> Zip<Self, F> { ... }
    fn map<B, F: Fn(Self::Item) -> B>(self, func: F) -> Map<Self, F> { ... }
    fn take(self, num: usize) -> Take<Self> { ... }
    fn flip(self) -> Flip<Self> { ... }
    fn dfs_preorder_iter(self) -> DfsPreOrderIter<Self>  { ... }
    fn dfs_inorder_iter(self) -> DfsInOrderIter<Self>  { ... }
    fn dfs_preorder(self, func: impl FnMut(Self::Item)) { ... }
    fn dfs_inorder(self, func: impl FnMut(Self::Item)) { ... }
    fn dfs_postorder(self, func: impl FnMut(Self::Item)) { ... }
}

The trait this crate revoles around. A complete binary tree visitor.

Required Associated Types

type Item

The common item produced for both leafs and non leafs.

Required Methods

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.

Provided Methods

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 with_depth(self, start_depth: Depth) -> LevelIter<Self>

Iterator Adapter to also produce the depth each iteration.

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

Combine two tree visitors.

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

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.

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.

fn dfs_inorder_iter(self) -> DfsInOrderIter<Self>

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 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.

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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a, T: 'a> Visitor for Vistr<'a, T, InOrder>

type Item = &'a T

impl<'a, T: 'a> Visitor for Vistr<'a, T, PostOrder>

type Item = &'a T

impl<'a, T: 'a> Visitor for Vistr<'a, T, PreOrder>

type Item = &'a T

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

type Item = &'a mut T

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

type Item = &'a mut T

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

type Item = &'a mut T

impl<B, C: Visitor, F: Fn(C::Item) -> B + Clone> Visitor for Map<C, F>

type Item = B

impl<T1: Visitor, T2: Visitor> Visitor for Zip<T1, T2>

type Item = (<T1 as Visitor>::Item, <T2 as Visitor>::Item)

impl<T: Visitor> Visitor for Flip<T>

type Item = <T as Visitor>::Item

impl<T: Visitor> Visitor for LevelIter<T>

type Item = (Depth, <T as Visitor>::Item)

impl<T: Visitor> Visitor for Take<T>

type Item = <T as Visitor>::Item