Struct indextree::Node

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

A node within a particular Arena.

Implementations

impl<T> Node<T>

pub fn get(&self) -> &T

Returns a reference to the node data.

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

Returns a mutable reference to the node data.

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

Returns the ID of the parent node, unless this node is the root of the tree.

Examples

// arena
// `-- 1
//     |-- 1_1
//     |-- 1_2
//     `-- 1_3
assert_eq!(arena[n1].parent(), None);
assert_eq!(arena[n1_1].parent(), Some(n1));
assert_eq!(arena[n1_2].parent(), Some(n1));
assert_eq!(arena[n1_3].parent(), Some(n1));

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

Returns the ID of the first child of this node, unless it has no child.

Examples

// arena
// `-- 1
//     |-- 1_1
//     |-- 1_2
//     `-- 1_3
assert_eq!(arena[n1].first_child(), Some(n1_1));
assert_eq!(arena[n1_1].first_child(), None);
assert_eq!(arena[n1_2].first_child(), None);
assert_eq!(arena[n1_3].first_child(), None);

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

Returns the ID of the last child of this node, unless it has no child.

Examples

// arena
// `-- 1
//     |-- 1_1
//     |-- 1_2
//     `-- 1_3
assert_eq!(arena[n1].last_child(), Some(n1_3));
assert_eq!(arena[n1_1].last_child(), None);
assert_eq!(arena[n1_2].last_child(), None);
assert_eq!(arena[n1_3].last_child(), None);

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

Returns the ID of the previous sibling of this node, unless it is a first child.

Examples

// arena
// `-- 1
//     |-- 1_1
//     |-- 1_2
//     `-- 1_3
assert_eq!(arena[n1].previous_sibling(), None);
assert_eq!(arena[n1_1].previous_sibling(), None);
assert_eq!(arena[n1_2].previous_sibling(), Some(n1_1));
assert_eq!(arena[n1_3].previous_sibling(), Some(n1_2));

Note that newly created nodes are independent toplevel nodes, and they are not siblings by default.

let mut arena = Arena::new();
let n1 = arena.new_node("1");
let n2 = arena.new_node("2");
// arena
// |-- (implicit)
// |   `-- 1
// `-- (implicit)
//     `-- 2
assert_eq!(arena[n1].previous_sibling(), None);
assert_eq!(arena[n2].previous_sibling(), None);

n1.insert_after(n2, &mut arena);
// arena
// `-- (implicit)
//     |-- 1
//     `-- 2
assert_eq!(arena[n1].previous_sibling(), None);
assert_eq!(arena[n2].previous_sibling(), Some(n1));

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

Returns the ID of the next sibling of this node, unless it is a last child.

Examples

// arena
// `-- 1
//     |-- 1_1
//     |-- 1_2
//     `-- 1_3
assert_eq!(arena[n1].next_sibling(), None);
assert_eq!(arena[n1_1].next_sibling(), Some(n1_2));
assert_eq!(arena[n1_2].next_sibling(), Some(n1_3));
assert_eq!(arena[n1_3].next_sibling(), None);

Note that newly created nodes are independent toplevel nodes, and they are not siblings by default.

let mut arena = Arena::new();
let n1 = arena.new_node("1");
let n2 = arena.new_node("2");
// arena
// |-- (implicit)
// |   `-- 1
// `-- (implicit)
//     `-- 2
assert_eq!(arena[n1].next_sibling(), None);
assert_eq!(arena[n2].next_sibling(), None);

n1.insert_after(n2, &mut arena);
// arena
// `-- (implicit)
//     |-- 1
//     `-- 2
assert_eq!(arena[n1].next_sibling(), Some(n2));
assert_eq!(arena[n2].next_sibling(), None);

pub fn is_removed(&self) -> bool

Checks if the node is marked as removed.

Examples

// arena
// `-- 1
//     |-- 1_1
//     |-- 1_2 *
//     `-- 1_3
assert_eq!(arena[n1_1].next_sibling(), Some(n1_2));
assert_eq!(arena[n1_2].parent(), Some(n1));
assert!(!arena[n1_2].is_removed());
assert_eq!(arena[n1_3].previous_sibling(), Some(n1_2));

n1_2.remove(&mut arena);
// arena
// `-- 1
//     |-- 1_1
//     `-- 1_3
assert_eq!(arena[n1_1].next_sibling(), Some(n1_3));
assert_eq!(arena[n1_2].parent(), None);
assert!(arena[n1_2].is_removed());
assert_eq!(arena[n1_3].previous_sibling(), Some(n1_1));

Trait Implementations

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

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

Returns a copy 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> Display for Node<T>

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

Formats the value using the given formatter.

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

fn eq(&self, other: &Node<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

impl<T> StructuralPartialEq for Node<T>