Trait TreeNodeMut 

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

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

Trait for mutable tree traversal.

This trait defines the interface required to iterate over a tree structure with mutable access to the nodes. Any type that implements this trait can be traversed using the provided mutable iterators.

Implementing this trait requires providing a way to access the children of a node mutably, which enables the iterator to traverse the tree structure.

Examples

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

// Create a simple tree
let mut tree = Node {
    value: 1,
    children: vec![Node::new(2), Node::new(3)],
};

// Mutably iterate and modify values
let mut iter = tree.iter_mut::<DepthFirst>();
while let Some(mut node) = iter.next() {
    node.value *= 2;
}

// Values have been doubled
assert_eq!(tree.value, 2);

Required Methods

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

Returns a mutable iterator over the children of this node.

This method must be implemented by all types implementing TreeNodeMut.

Provided Methods

fn iter_mut<T: TraversalOrder>(&mut self) -> TreeIterMut<'_, Self, T>

where Self: Sized,

Creates a mutable 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> TreeNodeMut for Node<T>

Implementation of TreeNodeMut for Node<T>.

This allows mutable iteration over the tree.