Struct Node

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

A container that wraps data in a given Tree.

Implementations

impl<T> Node<T>

pub fn new(data: T) -> Node<T>

Creates a new Node with the data provided.

use id_tree::Node;

let _one: Node<i32> = Node::new(1);

pub fn data(&self) -> &T

Returns an immutable reference to the data contained within the Node.

use id_tree::Node;

let node_three: Node<i32> = Node::new(3);
let three = 3;

assert_eq!(node_three.data(), &three);

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

Returns a mutable reference to the data contained within the Node.

use id_tree::Node;

let mut node_four: Node<i32> = Node::new(4);
let mut four = 4;

assert_eq!(node_four.data_mut(), &mut four);

pub fn replace_data(&mut self, data: T) -> T

Replaces this Nodes data with the data provided.

Returns the old value of data.

use id_tree::Node;

let mut node_four: Node<i32> = Node::new(3);

// ops! lets correct this
let three = node_four.replace_data(4);

assert_eq!(node_four.data(), &4);
assert_eq!(three, 3);

pub fn parent(&self) -> Option<&NodeId>

Returns a Some value containing the NodeId of this Node’s parent if it exists; returns None if it does not.

Note: A Node cannot have a parent until after it has been inserted into a Tree.

use id_tree::Node;

let five: Node<i32> = Node::new(5);

assert!(five.parent().is_none());

pub fn children(&self) -> &Vec<NodeId>

Returns an immutable reference to a Vec containing the NodeIds of this Node’s children.

Note: A Node cannot have any children until after it has been inserted into a Tree.

use id_tree::Node;

let six: Node<i32> = Node::new(6);

assert_eq!(six.children().len(), 0);

Trait Implementations

impl<T> Debug for Node<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> PartialEq for Node<T>

where T: PartialEq,

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.