Struct Node 

pub struct Node<T> {
    pub value: T,
    pub children: Vec<Node<T>>,
}

A generic tree node implementation.

This struct provides a simple implementation of a tree node with a value and a vector of children. It implements both TreeNode and TreeNodeMut traits, allowing it to be used with both immutable and mutable iterators.

Type Parameters

• T - The type of value stored in each node.

Examples

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

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

// Traverse in depth-first order
let values: Vec<i32> = tree.iter::<DepthFirst>()
                          .map(|node| node.value)
                          .collect();
assert_eq!(values, vec![1, 2, 3]);

Fields

value: T

The value stored in this node.

children: Vec<Node<T>>

The children of this node.

Implementations

impl<T> Node<T>

pub fn new(value: T) -> Self

Creates a new node with the given value and no children.

Parameters

• value - The value to store in the node.

Returns

A new Node with the given value and an empty children vector.

Trait Implementations

impl<T: Clone> Clone for Node<T>

fn clone(&self) -> Node<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Node<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Node<T>

fn default() -> Node<T>

Returns the “default value” for a type.

impl<T: Hash> Hash for Node<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq> PartialEq for Node<T>

fn eq(&self, other: &Node<T>) -> 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> TreeNode for Node<T>

Implementation of TreeNode for Node<T>.

This allows immutable iteration over the tree.

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

Returns an iterator over the children of this node.

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

where Self: Sized,

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

impl<T> TreeNodeMut for Node<T>

Implementation of TreeNodeMut for Node<T>.

This allows mutable iteration over the tree.

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

Returns a mutable iterator over the children of this node.

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.

impl<T: Eq> Eq for Node<T>

impl<T> StructuralPartialEq for Node<T>