Struct CursorMut 

pub struct CursorMut<'a, T> { /* private fields */ }

A mutable Cursor can freely visit node in tree

Implementations

impl<'a, T> CursorMut<'a, T>

pub fn move_child(&mut self, at: usize)

Move this cursor to the specified child

Panics

Panics if ‘at’ >= children_count()

Examples found in repository

examples/basic.rs (line 17)

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 move_parent(&mut self)

move this cursor to its parent. Do nothing if it is already in the root node.

Examples found in repository

examples/basic.rs (line 19)

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 move_root(&mut self)

Move this cursor to its root. Do nothing if it is already in the root node.

pub fn current(&self) -> &'a mut T

Return the reference to the current

Examples found in repository

examples/basic.rs (line 18)

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 children_count(&self) -> usize

Get the count of children in current node

pub fn children(&self) -> ChildrenIterMut<'a, T>

Get a immutable children iterator

pub fn is_root(&self) -> bool

Return true if current node is the root

pub fn is_leaf(&self) -> bool

Return true if current node is a leaf

pub fn remove(self) -> Option<Tree<T>>

Remove a sub-tree and consume the cursor
return None when current node is root

Examples found in repository

examples/basic.rs (line 21)

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 add_child(&mut self, tree: Tree<T>)

Add a sub-tree to children of current node