Struct tree_cursor::cursor::TreeCursorMut

pub struct TreeCursorMut<'n, N: 'n> { /* fields omitted */ }

A cursor that holds a mutable reference to its tree.

Methods

impl<'n, N: 'n> TreeCursorMut<'n, N>

pub fn new(root: &'n mut N) -> Self

Creates a new TreeCursorMut starting at root.

pub fn down_map<F>(&mut self, f: F) -> bool where
    F: Fn(&'n mut N, usize) -> Option<&'n mut N>, 

Passes f the active node and the current value of the "next child" counter. If f returns a node, it's set as the active node, the old active node's "next child" counter is incremented, and this method returns true. Otherwise, this method returns false.

pub fn down_map_new<F>(&mut self, f: F) -> Option<Self> where
    F: Fn(&'n mut N, usize) -> Option<&'n mut N>, 

Like down_new, except that it takes a closure like down_map.

pub fn zero(&mut self)

Resets the active node's "next child" counter to 0.

pub fn up(&mut self) -> bool

Moves the cursor up one node. Returns true if there was a node to move to, and false otherwise. In both cases, the old active node's "next child" counter is reset, as if zero had been called.

pub fn get(&self) -> &N

Returns a shared reference to the active node.

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

Returns a mutable reference to the active node.

impl<'n, N: 'n + DownMut> TreeCursorMut<'n, N>

pub fn down(&mut self) -> bool

Moves the cursor down one node. The node to move to is determined by calling [DownMut::down_mut] on the active node and passing it the "next child" counter. Returns true and increments the old active node's "next child" counter if there was a node to move to, and returns false otherwise.

pub fn down_new(&mut self) -> Option<Self>

Like down, except instead of moving the position of self, it returns a new TreeCursorMut whose root is the new position. self is frozen until the new cursor goes out of scope.

Trait Implementations

impl<'n, N: Debug + 'n> Debug for TreeCursorMut<'n, N>

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

Formats the value using the given formatter.

impl<'n, N: Eq + 'n> Eq for TreeCursorMut<'n, N>

impl<'n, N: Hash + 'n> Hash for TreeCursorMut<'n, N>

fn hash<__HN: Hasher>(&self, __arg_0: &mut __HN)

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<'n, N: PartialEq + 'n> PartialEq for TreeCursorMut<'n, N>

fn eq(&self, __arg_0: &TreeCursorMut<'n, N>) -> bool

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

fn ne(&self, __arg_0: &TreeCursorMut<'n, N>) -> bool

This method tests for !=.