Struct treelike::example::LinTree

pub struct LinTree<'a, T> { /* fields omitted */ }

A tree whose nodes are stored in a backing slice.

The root node is at index 0 and the child nodes at index*2 + 1 and index*2 + 2.

Used in most examples, as it is easy to initialize.

Also shows a case where Treelike is implemented on the node itself, and not a reference to one. An important pitfall for that is that you may need to manually implement Copy and Clone as deriving them places Copy/Clone bounds on all type parameters (T in this case), even though that might not be necessary due to the content not being stored in-line, and therefore not being Copy/Cloned.

Methods

impl<'a, T> LinTree<'a, T>

pub fn new(index: usize, slice: &'a [T]) -> Self

Trait Implementations

impl<'a, T: Debug> Treelike for LinTree<'a, T>

type Content = &'a T

The content of the current node.

type ChildIterator = FlatMap<Zip<Chain<Once<usize>, Once<usize>>, Repeat<&'a [T]>>, Option<LinTree<'a, T>>, fn(_: (usize, &'a [T])) -> Option<LinTree<'a, T>>>

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 content(self) -> Self::Content

Has to produce this nodes Content.

fn children(self) -> Self::ChildIterator

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

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

This is also an example of overriding the Treelikes default implementations where necessary. LinTree can provide breadth-first traversal with a simple iteration

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_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<'a, T: Debug> Debug for LinTree<'a, T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a, T> Copy for LinTree<'a, T>

impl<'a, T> Clone for LinTree<'a, T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.