Struct NodeChildren

pub struct NodeChildren { /* private fields */ }

A concrete implementation of the Children trait using a vector of boxed nodes.

NodeChildren is the primary implementation for storing and managing collections of tree nodes. It provides efficient access, modification, and iteration over child nodes.

Examples

use lipgloss_tree::{NodeChildren, Leaf, Children};

let mut children = NodeChildren::new();
children.append(Box::new(Leaf::new("First", false)));
children.append(Box::new(Leaf::new("Second", false)));

assert_eq!(children.length(), 2);

Implementations

impl NodeChildren

pub fn new() -> Self

Creates a new empty NodeChildren collection.

Examples

use lipgloss_tree::{NodeChildren, Children};

let children = NodeChildren::new();
assert_eq!(children.length(), 0);

pub fn from_nodes(nodes: Vec<Box<dyn Node>>) -> Self

Creates a NodeChildren collection from a vector of boxed nodes.

Arguments

• nodes - A vector of boxed nodes to initialize the collection with

Examples

use lipgloss_tree::{NodeChildren, Leaf, Children};

let nodes = vec![
    Box::new(Leaf::new("A", false)) as Box<dyn lipgloss_tree::Node>,
    Box::new(Leaf::new("B", false)) as Box<dyn lipgloss_tree::Node>,
];
let children = NodeChildren::from_nodes(nodes);
assert_eq!(children.length(), 2);

pub fn append(&mut self, child: Box<dyn Node>)

Appends a child node to the end of the collection.

Arguments

• child - The boxed node to add to the collection

Examples

use lipgloss_tree::{NodeChildren, Leaf, Children};

let mut children = NodeChildren::new();
children.append(Box::new(Leaf::new("New Item", false)));
assert_eq!(children.length(), 1);

pub fn remove(&mut self, index: usize) -> Option<Box<dyn Node>>

Removes and returns the child node at the given index.

Arguments

• index - The zero-based index of the node to remove

Returns

The removed node if the index was valid, or None if out of bounds

Examples

use lipgloss_tree::{NodeChildren, Leaf, Children};

let mut children = NodeChildren::new();
children.append(Box::new(Leaf::new("Remove me", false)));

let removed = children.remove(0);
assert!(removed.is_some());
assert_eq!(children.length(), 0);

pub fn at_mut(&mut self, index: usize) -> Option<&mut Box<dyn Node>>

Returns a mutable reference to the boxed node at the given index.

This allows you to modify the node in place or replace it entirely.

Arguments

• index - The zero-based index of the desired node

Returns

A mutable reference to the boxed node, or None if the index is out of bounds

Examples

use lipgloss_tree::{NodeChildren, Leaf, Node};

let mut children = NodeChildren::new();
children.append(Box::new(Leaf::new("Original", false)));

if let Some(node) = children.at_mut(0) {
    node.set_value("Modified".to_string());
}

Trait Implementations

impl Children for NodeChildren

fn at(&self, index: usize) -> Option<&dyn Node>

Returns the node at the given index.

fn length(&self) -> usize

Returns the total number of children in this collection.

impl Clone for NodeChildren

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for NodeChildren

fn default() -> Self

Creates a default (empty) NodeChildren collection.

Equivalent to NodeChildren::new() - creates an empty collection with no child nodes.