Struct Tree

pub struct Tree<T> { /* private fields */ }

A Tree of Nodes. The root of the Tree has no parent.

Ownership

When a Node method returns this type, it means it is passing ownership of the Nodes.

When a Node method asks for this type as argument, it means it is taking ownership of the Nodes.

Implementations

impl<T> Tree<T>

pub fn builder(content: T) -> NodeBuilder<T>

pub fn root(&self) -> &Node<T>

pub fn root_mut(&mut self) -> Pin<&mut Node<T>>

pub fn detach_descendant( &mut self, descendant: NonNull<Node<T>>, ) -> Option<Self>

Removes the descendant of the root Node from the Tree, and returns the detached Node with ownership (aka a Tree).

Returns None if it is not a descendant of the root, or root is_same_as descendant.

This function can only be called from the root Node.

descendant must be a NonNull pointer (obtained from Node::ptr) because, if it was a reference, the borrow checker will consider the entire Tree to be immutably borrowed (including self). The descendant pointer passed to this function will remain valid because it is Pinned.

Example

let target = tree.root().children()[1].ptr();
let detached = tree.detach_descendant(target).unwrap();
assert!(detached.root().is_same_as(target));

pub fn borrow_descendant( &mut self, descendant: NonNull<Node<T>>, ) -> Option<Pin<&mut Node<T>>>

Mutably borrows a descendant of the Tree’s root Node as mutable. See Mutable Iterators section for why obtaining a &mut Node was implemented this way.

Returns None if it is not a descendant of the root, or root is_same_as descendant.

This function can be used to mutably borrow a Node obtained by a Node iterator.

descendant must be a NonNull pointer (obtained from Node::ptr) because, if it was a reference, the borrow checker will consider the entire Tree to be immutably borrowed (including self). The descendant pointer passed to this function will remain valid because it is Pinned.

Example

let target = tree.iter_bfs().find(|n| n.content == 'c').unwrap().ptr();
let borrowed = tree.borrow_descendant(target).unwrap();
assert!(borrowed.is_same_as(target));

It should be enough to assert that the whole Tree is mut, so by extension the descendant is also mut.

pub fn iter_bfs(&self) -> IterBFS<'_, T>

Iterate over all the Nodes of the Tree using Breadth-First Search.

pub fn iter_dfs(&self) -> IterDFS<'_, T>

Iterate over all the Nodes of the Tree using Depth-First Search.

Trait Implementations

impl<T: Clone> Clone for Tree<T>

fn clone(&self) -> Self

Clones the entire Tree by calling Node::clone_deep() on the root.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Tree<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Tree<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<NodeBuilder<T>> for Tree<T>

fn from(builder: NodeBuilder<T>) -> Self

Converts to this type from the input type.

impl<'a, T> IntoIterator for &'a Tree<T>

type Item = &'a Node<T>

The type of the elements being iterated over.

type IntoIter = IterBFS<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for Tree<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for Tree<T>