Struct Tree 

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

The type representing a Tree

Implementations

impl<T> Tree<T>

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

Create a tree only have one node with value

Example

use xtree::Tree;
let tree = Tree::new(3);

!! Use tr! macro to instead

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

Add a child to root

Example

let mut t1 = tr!(1);
let t2 = tr!(2);
t1.add_child(t2);

!! Use ‘/’ operator to instead

pub fn cursor(&self) -> Cursor<'_, T>

Get a immutable Cursor which points the root

Examples found in repository

examples/basic.rs (line 29)

fn main(){
    let mut tree =
        tr!(1)
            / (tr!(2)
                / tr!(5)
                / tr!(6))
            / (tr!(3)
                / tr!(7)
                / tr!(8))
            / tr!(4);

    let mut cursor = tree.cursor_mut();
    cursor.move_child(0);
    *cursor.current() = 10;
    cursor.move_parent();
    cursor.move_child(1);
    let sub_tree = cursor.remove().unwrap();
    for (depth,node) in sub_tree.df_iter().depth(){
        for _ in 0..depth {
            print!("-");
        }
        println!("{}",node);
    }

    let mut cursor = tree.cursor();
    println!("children of root:");
    for child in cursor.children() {
        print!("{} ",child)
    }
    println!();
    println!("root:{}",cursor.current());
    cursor.move_child(0);
    println!("first child:{}",cursor.current());
    cursor.move_parent();
    cursor.move_child(1);
    println!("second child:{}",cursor.current());

    for itr in tree.df_iter_mut() {
        *itr += 1;
        print!("{} ",itr);
    }
    println!();

    for (depth,node) in tree.df_iter().depth(){
        for _ in 0..depth {
            print!("-");
        }
        println!("{}",node);
    }

    for itr in tree.bf_iter(){
        print!("{} ",itr);
    }
}

pub fn cursor_mut(&mut self) -> CursorMut<'_, T>

Get a mutable Cursor which points the root

Examples found in repository

examples/basic.rs (line 16)

fn main(){
    let mut tree =
        tr!(1)
            / (tr!(2)
                / tr!(5)
                / tr!(6))
            / (tr!(3)
                / tr!(7)
                / tr!(8))
            / tr!(4);

    let mut cursor = tree.cursor_mut();
    cursor.move_child(0);
    *cursor.current() = 10;
    cursor.move_parent();
    cursor.move_child(1);
    let sub_tree = cursor.remove().unwrap();
    for (depth,node) in sub_tree.df_iter().depth(){
        for _ in 0..depth {
            print!("-");
        }
        println!("{}",node);
    }

    let mut cursor = tree.cursor();
    println!("children of root:");
    for child in cursor.children() {
        print!("{} ",child)
    }
    println!();
    println!("root:{}",cursor.current());
    cursor.move_child(0);
    println!("first child:{}",cursor.current());
    cursor.move_parent();
    cursor.move_child(1);
    println!("second child:{}",cursor.current());

    for itr in tree.df_iter_mut() {
        *itr += 1;
        print!("{} ",itr);
    }
    println!();

    for (depth,node) in tree.df_iter().depth(){
        for _ in 0..depth {
            print!("-");
        }
        println!("{}",node);
    }

    for itr in tree.bf_iter(){
        print!("{} ",itr);
    }
}

pub fn df_iter(&self) -> DfIter<'_, T>

Get a immutable Depth-First iterator

Examples found in repository

examples/basic.rs (line 22)

fn main(){
    let mut tree =
        tr!(1)
            / (tr!(2)
                / tr!(5)
                / tr!(6))
            / (tr!(3)
                / tr!(7)
                / tr!(8))
            / tr!(4);

    let mut cursor = tree.cursor_mut();
    cursor.move_child(0);
    *cursor.current() = 10;
    cursor.move_parent();
    cursor.move_child(1);
    let sub_tree = cursor.remove().unwrap();
    for (depth,node) in sub_tree.df_iter().depth(){
        for _ in 0..depth {
            print!("-");
        }
        println!("{}",node);
    }

    let mut cursor = tree.cursor();
    println!("children of root:");
    for child in cursor.children() {
        print!("{} ",child)
    }
    println!();
    println!("root:{}",cursor.current());
    cursor.move_child(0);
    println!("first child:{}",cursor.current());
    cursor.move_parent();
    cursor.move_child(1);
    println!("second child:{}",cursor.current());

    for itr in tree.df_iter_mut() {
        *itr += 1;
        print!("{} ",itr);
    }
    println!();

    for (depth,node) in tree.df_iter().depth(){
        for _ in 0..depth {
            print!("-");
        }
        println!("{}",node);
    }

    for itr in tree.bf_iter(){
        print!("{} ",itr);
    }
}

pub fn df_iter_mut(&mut self) -> DfIterMut<'_, T>

Get a mutable Depth-First iterator

Examples found in repository

examples/basic.rs (line 42)

fn main(){
    let mut tree =
        tr!(1)
            / (tr!(2)
                / tr!(5)
                / tr!(6))
            / (tr!(3)
                / tr!(7)
                / tr!(8))
            / tr!(4);

    let mut cursor = tree.cursor_mut();
    cursor.move_child(0);
    *cursor.current() = 10;
    cursor.move_parent();
    cursor.move_child(1);
    let sub_tree = cursor.remove().unwrap();
    for (depth,node) in sub_tree.df_iter().depth(){
        for _ in 0..depth {
            print!("-");
        }
        println!("{}",node);
    }

    let mut cursor = tree.cursor();
    println!("children of root:");
    for child in cursor.children() {
        print!("{} ",child)
    }
    println!();
    println!("root:{}",cursor.current());
    cursor.move_child(0);
    println!("first child:{}",cursor.current());
    cursor.move_parent();
    cursor.move_child(1);
    println!("second child:{}",cursor.current());

    for itr in tree.df_iter_mut() {
        *itr += 1;
        print!("{} ",itr);
    }
    println!();

    for (depth,node) in tree.df_iter().depth(){
        for _ in 0..depth {
            print!("-");
        }
        println!("{}",node);
    }

    for itr in tree.bf_iter(){
        print!("{} ",itr);
    }
}

pub fn bf_iter(&self) -> BfIter<'_, T>

Get a immutable Breadth-first iterator

Examples found in repository

examples/basic.rs (line 55)

fn main(){
    let mut tree =
        tr!(1)
            / (tr!(2)
                / tr!(5)
                / tr!(6))
            / (tr!(3)
                / tr!(7)
                / tr!(8))
            / tr!(4);

    let mut cursor = tree.cursor_mut();
    cursor.move_child(0);
    *cursor.current() = 10;
    cursor.move_parent();
    cursor.move_child(1);
    let sub_tree = cursor.remove().unwrap();
    for (depth,node) in sub_tree.df_iter().depth(){
        for _ in 0..depth {
            print!("-");
        }
        println!("{}",node);
    }

    let mut cursor = tree.cursor();
    println!("children of root:");
    for child in cursor.children() {
        print!("{} ",child)
    }
    println!();
    println!("root:{}",cursor.current());
    cursor.move_child(0);
    println!("first child:{}",cursor.current());
    cursor.move_parent();
    cursor.move_child(1);
    println!("second child:{}",cursor.current());

    for itr in tree.df_iter_mut() {
        *itr += 1;
        print!("{} ",itr);
    }
    println!();

    for (depth,node) in tree.df_iter().depth(){
        for _ in 0..depth {
            print!("-");
        }
        println!("{}",node);
    }

    for itr in tree.bf_iter(){
        print!("{} ",itr);
    }
}

pub fn bf_iter_mut(&mut self) -> BfIterMut<'_, T>

Get a mutable Breadth-First iterator

Trait Implementations

impl<T> Div for Tree<T>

type Output = Tree<T>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.