Struct TreeNode 

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

A node in the tree hierarchy.

Implementations

impl<T: Clone> TreeNode<T>

pub fn new(label: impl Into<String>, data: T) -> Self

Creates a new tree node with a label and data.

Example

use envision::component::TreeNode;

let node = TreeNode::new("Documents", "/home/user/docs");
assert_eq!(node.label(), "Documents");
assert_eq!(node.data(), &"/home/user/docs");

pub fn new_expanded(label: impl Into<String>, data: T) -> Self

Creates a new node that starts expanded.

Example

use envision::component::TreeNode;

let node: TreeNode<()> = TreeNode::new_expanded("Root", ());
assert!(node.is_expanded());

pub fn label(&self) -> &str

Returns the node’s label.

pub fn set_label(&mut self, label: impl Into<String>)

Sets the node’s label.

Example

use envision::component::TreeNode;

let mut node = TreeNode::new("Old", ());
node.set_label("New");
assert_eq!(node.label(), "New");

pub fn data(&self) -> &T

Returns a reference to the node’s data.

Example

use envision::component::TreeNode;

let node = TreeNode::new("Root", 42u32);
assert_eq!(node.data(), &42u32);

pub fn data_mut(&mut self) -> &mut T

Returns a mutable reference to the node’s data.

Example

use envision::component::TreeNode;

let mut node = TreeNode::new("Root", 0u32);
*node.data_mut() = 99;
assert_eq!(node.data(), &99u32);

pub fn children(&self) -> &[TreeNode<T>]

Returns the children of this node.

Example

use envision::component::TreeNode;

let mut parent = TreeNode::new("Parent", ());
parent.add_child(TreeNode::new("Child", ()));
assert_eq!(parent.children().len(), 1);

pub fn children_mut(&mut self) -> &mut Vec<TreeNode<T>>

Returns a mutable reference to the children.

Example

use envision::component::TreeNode;

let mut node = TreeNode::new("Root", ());
node.children_mut().push(TreeNode::new("Child", ()));
assert_eq!(node.children().len(), 1);

pub fn add_child(&mut self, child: TreeNode<T>)

Adds a child node.

Example

use envision::component::TreeNode;

let mut parent = TreeNode::new("Parent", ());
parent.add_child(TreeNode::new("Child", ()));
assert_eq!(parent.children().len(), 1);

pub fn has_children(&self) -> bool

Returns true if this node has children.

Example

use envision::component::TreeNode;

let mut parent = TreeNode::new("Parent", ());
assert!(!parent.has_children());
parent.add_child(TreeNode::new("Child", ()));
assert!(parent.has_children());

pub fn is_expanded(&self) -> bool

Returns true if this node is expanded.

Example

use envision::component::TreeNode;

let node = TreeNode::new("Root", ());
assert!(!node.is_expanded());

pub fn set_expanded(&mut self, expanded: bool)

Sets the expanded state.

Example

use envision::component::TreeNode;

let mut node = TreeNode::new("Root", ());
node.set_expanded(true);
assert!(node.is_expanded());

pub fn expand(&mut self)

Expands this node.

Example

use envision::component::TreeNode;

let mut node = TreeNode::new("Root", ());
node.expand();
assert!(node.is_expanded());

pub fn collapse(&mut self)

Collapses this node.

Example

use envision::component::TreeNode;

let mut node = TreeNode::new_expanded("Root", ());
node.collapse();
assert!(!node.is_expanded());

pub fn toggle(&mut self)

Toggles the expanded state.

Example

use envision::component::TreeNode;

let mut node = TreeNode::new("Root", ());
node.toggle();
assert!(node.is_expanded());
node.toggle();
assert!(!node.is_expanded());

Trait Implementations

impl<T: Clone> Clone for TreeNode<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for TreeNode<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for TreeNode<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq> PartialEq for TreeNode<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> Serialize for TreeNode<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.