Struct treelike::example::OwningBinaryTree

pub struct OwningBinaryTree<Content> { /* fields omitted */ }

A basic binary tree that stores its children in Box-es on the heap. Used to show off trees that own the complete data and don't rely on any backing storage.

Trait Implementations

impl<'a, TreeCont> Treelike for &'a OwningBinaryTree<TreeCont>

type Content = &'a TreeCont

The content of the current node.

fn content(self) -> Self::Content

Has to produce this nodes Content.

type ChildIterator = Map<Flatten<Iter<'a, Option<Box<OwningBinaryTree<TreeCont>>>>>, fn(_: &Box<OwningBinaryTree<TreeCont>>) -> &OwningBinaryTree<TreeCont>>

You will have to specify the precise type you use for child iteration. This also implies that you have to move any closures into free standing functions. This is an Iterator over the children, not the contents of the children.

fn children(self) -> Self::ChildIterator

Has to return an Iterator over all this nodes direct children.

fn left(self) -> Option<Self>

Returns leftmost direct child of this Node. Mostly useful for binary trees.

fn right(self) -> Option<Self>

Returns rightmost direct child of this Node. Mostly useful for binary trees.

fn first(self) -> Self::Content

Recursively traverses the tree to the very first/leftmost node.

fn last(self) -> Self::Content

Recursively traverses the tree to the very last/rightmost node.

fn callback_dft<CB: FnMut(Self::Content, usize), F: FilterBuilder<Self>>(
    self,
    callback: CB,
    child_filter: F
)

Traverses the tree depth first, post order, i.e. children's contents are visited before their parents.

fn callback_dft_pre<CB: FnMut(Self::Content, usize), F: FilterBuilder<Self>>(
    self,
    callback: CB,
    child_filter: F
)

like callback_dft but the parents content is visited before the children's.

fn callback_bft<CB: FnMut(Self::Content, usize)>(self, callback: CB)

Traverses the tree breadth-first, i.e. one depth-layer at a time. # Example ``` # use treelike::example::LinTree; # use treelike::Treelike; let base = [3, 4, 5, 6, 7]; let node = LinTree::new(0, &base);

fn callback_bft_filtered<CB: FnMut(Self::Content, usize), F: FilterBuilder<Self>>(
    self,
    callback: CB,
    filter: F
)

Like callback_bft but allows filtering, thereby disallowing some optimizations.

Important traits for DFT<T, F>

impl<T: Treelike, F: FilterBuilder<T>> Iterator for DFT<T, F> type Item = T::Content;

fn iter_dft<F: FilterBuilder<Self>>(self, filter: F) -> DFT<Self, F>

Important traits for DFTP<T, F>

impl<T: Treelike, F: FilterBuilder<T>> Iterator for DFTP<T, F> type Item = T::Content;

fn iter_dft_pre<F: FilterBuilder<Self>>(self, filter: F) -> DFTP<Self, F>

fn iter_bft<F: FilterBuilder<Self>>(
    self,
    filter: F
) -> Chain<Once<Self::Content>, BFT<Self, F>>

impl<Content: Default> Default for OwningBinaryTree<Content>

fn default() -> Self

Returns the "default value" for a type.