Struct TreeNode 

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

A single tree node

Fields

value: T

Implementations

impl<T> TreeNode<T>

pub fn new(value: T) -> NodeRef<T>

Create a new node wrapped in Rc<RefCell<_>>

pub fn parent(&self) -> Option<NodeRef<T>>

Returns the parent node, if any

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

Returns slice of child nodes

pub fn clear_children(&mut self)

Remove all children of this node

pub fn add_child(parent: &NodeRef<T>, child: NodeRef<T>)

Add a child node

pub fn remove_child( parent: &NodeRef<T>, child: &NodeRef<T>, ) -> Option<NodeRef<T>>

Removes child from parent, returning the detached node when found.

pub fn detach(node: &NodeRef<T>) -> bool

Detaches a node from its current parent.

pub fn append_child(parent: &NodeRef<T>, child: NodeRef<T>) -> bool

Appends child, moving it from its current parent when necessary.

Returns false when the operation would create a tree cycle.

pub fn insert_before( parent: &NodeRef<T>, child: NodeRef<T>, reference: &NodeRef<T>, ) -> bool

Inserts child immediately before reference, moving it from its current parent when necessary.

pub fn is_inclusive_ancestor(ancestor: &NodeRef<T>, node: &NodeRef<T>) -> bool

pub fn insert_child_at(parent: &NodeRef<T>, index: usize, child: NodeRef<T>)

Insert a child at a given position

pub fn add_child_value(parent: &NodeRef<T>, value: T) -> NodeRef<T>

Create a child with value and add it to parent

pub fn replace_child( parent: &NodeRef<T>, index: usize, new_child: NodeRef<T>, ) -> Option<NodeRef<T>>

Replace child at given index

pub fn find_children_by<F>(&self, predicate: F) -> Vec<NodeRef<T>>

where F: Fn(&T) -> bool,

Find direct children matching predicate

pub fn clone_node(&self, deep: bool) -> NodeRef<T>

where T: Clone,

Clone node (optionally deep)

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.