Trait TreeNode 

pub trait TreeNode {
    // Required method
    fn children(&self) -> impl DoubleEndedIterator<Item = &Self>;

    // Provided method
    fn iter<T: TraversalOrder>(&self) -> TreeIter<'_, Self, T>
       where Self: Sized { ... }
}

Trait for immutable tree traversal.

This trait defines the interface required to iterate over a tree structure in an immutable fashion. Any type that implements this trait can be traversed using the provided iterators.

Examples

use tree_iter::prelude::*;
use tree_iter::tree::Node;

// Create a custom tree structure
struct MyTree<T> {
    value: T,
    children: Vec<MyTree<T>>,
}

// Implement TreeNode for custom tree structure
impl<T> TreeNode for MyTree<T> {
    fn children(&self) -> impl DoubleEndedIterator<Item = &Self> {
        self.children.iter()
    }
}

// Now you can use the tree iterator
let my_tree = MyTree {
    value: 1,
    children: vec![
        MyTree { value: 2, children: vec![] },
        MyTree { value: 3, children: vec![] },
    ],
};

let values: Vec<i32> = my_tree.iter::<DepthFirst>()
                            .map(|node| node.value)
                            .collect();

Required Methods

fn children(&self) -> impl DoubleEndedIterator<Item = &Self>

Returns an iterator over the children of this node.

This method must be implemented by all types implementing TreeNode.

Provided Methods

fn iter<T: TraversalOrder>(&self) -> TreeIter<'_, Self, T>

where Self: Sized,

Creates an iterator that traverses the tree starting from this node.

Type Parameters

• T - The traversal order strategy to use (e.g., DepthFirst or BreadthFirst).

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<T> TreeNode for Node<T>

Implementation of TreeNode for Node<T>.

This allows immutable iteration over the tree.