Struct trees::Node

pub struct Node<T> {
    pub data: T,
    // some fields omitted
}

Tree node implemented in singly-linked-children / circularly-linked-siblings.

Fields

data: T

Methods

impl<T> Node<T>

pub fn adopt(&mut self, children: Forest<T>)

Append the given trees at the end of the Node's children list.

pub fn abandon(&mut self) -> Forest<T>

Removes and returns the given tree Node's children.

Examples

use trees::tr;

let mut tree = tr(0) /tr(1)/tr(2);
let children = tree.abandon();
assert_eq!( tree, tr(0) );
assert_eq!( children, -tr(1)-tr(2) );

pub fn push_front(&mut self, child: Tree<T>)

Adds the child as the first child.

Examples

use trees::tr;

let mut tree = tr(0) /tr(1);
tree.push_front( tr(2) );
let mut iter = tree.children();
assert_eq!( iter.next().unwrap().to_owned(), tr(2) );
assert_eq!( iter.next().unwrap().to_owned(), tr(1) );
assert_eq!( iter.next(), None );

pub fn pop_front(&mut self) -> Option<Tree<T>>

remove and return the first child

Examples

use trees::tr;

let mut tree = tr(0) /tr(1)/tr(2);
let child = tree.pop_front();
assert_eq!( tree, tr(0) /tr(2) );
assert_eq!( child.unwrap(), tr(1) );

pub fn push_back(&mut self, child: Tree<T>)

add the child as the last child

Examples

use trees::tr;

let mut tree = tr(0) /tr(1);
tree.push_back( tr(2) );
let mut iter = tree.children();
assert_eq!( iter.next().unwrap().to_owned(), tr(1) );
assert_eq!( iter.next().unwrap().to_owned(), tr(2) );
assert_eq!( iter.next(), None );

Important traits for Iter<'a, T>

impl<'a, T: 'a> Iterator for Iter<'a, T> type Item = &'a Node<T>;

pub fn children(&self) -> Iter<T>

Provides a forward iterator over tree Node's direct decendants

Examples

use trees::tr;

let tree = tr(0)
    /( tr(1) /tr(2)/tr(3) )
    /( tr(4) /tr(5)/tr(6) )
;
let mut iter = tree.children();
assert_eq!( iter.next().unwrap().to_owned(), tr(1) /tr(2)/tr(3) );
assert_eq!( iter.next().unwrap().to_owned(), tr(4) /tr(5)/tr(6) );
assert_eq!( iter.next(), None );

Important traits for IterMut<'a, T>

impl<'a, T: 'a> Iterator for IterMut<'a, T> type Item = &'a mut Node<T>;

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

Provides a forward iterator over tree Node's direct decendants with mutable references.

Examples

use trees::tr;

let mut tree = tr(0)
    /( tr(1) /tr(2)/tr(3) )
    /( tr(4) /tr(5)/tr(6) )
;
for mut child in tree.children_mut() {
    child.data *= 10;
}
let expedted = tr(0)
    /( tr(10) /tr(2)/tr(3) )
    /( tr(40) /tr(5)/tr(6) )
;
assert_eq!( tree, expedted );

Important traits for SubtreeIter<T>

impl<T> Iterator for SubtreeIter<T> type Item = Subtree<T>;

pub fn subtrees(&mut self) -> SubtreeIter<T>

Provide an iterator over the tree Node's subtrees for insert/remove at any position

Examples

insert after

use trees::tr;

let mut tree = tr(0) /tr(1)/tr(2)/tr(3);
for mut sub in tree.subtrees() {
    sub.insert_sib( tr(3) );
}
assert_eq!( tree, tr(0) /tr(1)/tr(3)/tr(2)/tr(3)/tr(3)/tr(3) );

insert before

use trees::tr;

let mut tree = tr(0) /tr(1)/tr(3)/tr(4);
let mut iter = tree.subtrees().peekable();
while let Some(mut sub) = iter.next() { 
    if let Some(next_sub) = iter.peek() {
        if next_sub.data == 3 {
            sub.insert_sib( tr(2) );
        }
    }
}
assert_eq!( tree, tr(0) /tr(1)/tr(2)/tr(3)/tr(4) );

remove

use trees::tr;
let mut tree = tr(0) /tr(1)/tr(2)/tr(3)/tr(4)/tr(5)/tr(6);
for mut sub in tree.subtrees() {
    let d = sub.data;
    if d%2 == 0 || d%3 == 0 {
        sub.remove();
    }
}
assert_eq!( tree, tr(0) /tr(1)/tr(5) );

pub fn is_leaf(&self) -> bool

Returns true if the Node has no children.

This operation should compute in O(1) time.

Examples

use trees::{tr};

let mut tree = tr(0);
assert!( tree.is_leaf() );
tree.push_back( tr(1) ); 
assert!( !tree.is_leaf() );

Trait Implementations

impl<T> Extend<Tree<T>> for Node<T>

fn extend<I: IntoIterator<Item = Tree<T>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

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

fn eq(&self, other: &Self) -> bool

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

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

This method tests for !=.

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

impl<T: PartialOrd> PartialOrd for Node<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Ord> Ord for Node<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl<T> Borrow<Node<T>> for Tree<T>

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

Immutably borrows from an owned value.

impl<T> BorrowMut<Node<T>> for Tree<T>

fn borrow_mut(&mut self) -> &mut Node<T>

Mutably borrows from an owned value.

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

type Owned = Tree<T>

fn to_owned(&self) -> Tree<T>

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning.

impl<T> Drop for Node<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Hash> Hash for Node<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T: Debug> Debug for Node<T>

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

Formats the value using the given formatter.

impl<T: Display> Display for Node<T>

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

Formats the value using the given formatter.

impl<T: Send> Send for Node<T>

impl<T: Sync> Sync for Node<T>