Struct TreeCursor

pub struct TreeCursor<'n: 'f, 'f, N: 'n> { /* private fields */ }

A cursor that holds a shared reference to its tree.

Implementations

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

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

Creates a new TreeCursor starting at root.

impl<'n: 'f, 'f, N: 'n> TreeCursor<'n, 'f, N>

pub fn down_map<F>(&mut self, f: F) -> bool

where F: Fn(&'n N, usize) -> Option<&'n 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<'s, F>(&'s mut self, f: F) -> Option<TreeCursor<'n, 's, N>>

where F: Fn(&'n N, usize) -> Option<&'n 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 take<'s>(&'s mut self) -> Option<TreeCursor<'n, 's, N>>

Takes the active node from this TreeCursor and returns a new TreeCursor at that position. self is frozen until the new cursor goes out of scope.

pub fn get(&self) -> &N

Returns a shared reference to the active node.

impl<'n: 'f, 'f, N: 'n + Down> TreeCursor<'n, 'f, N>

pub fn down(&mut self) -> bool

Moves the cursor down one node. The node to move to is determined by calling Down::down 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<'s>(&'s mut self) -> Option<TreeCursor<'n, 's, N>>

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

Trait Implementations

impl<'n: 'f, 'f, N: Clone + 'n> Clone for TreeCursor<'n, 'f, N>

fn clone(&self) -> TreeCursor<'n, 'f, N>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'n: 'f, 'f, N: Debug + 'n> Debug for TreeCursor<'n, 'f, N>

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

Formats the value using the given formatter.

impl<'n: 'f, 'f, N: 'n> From<TreeCursorMut<'n, 'f, N>> for TreeCursor<'n, 'f, N>

fn from(cm: TreeCursorMut<'n, 'f, N>) -> Self

Converts to this type from the input type.

impl<'n: 'f, 'f, N: Hash + 'n> Hash for TreeCursor<'n, 'f, N>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'n: 'f, 'f, N: PartialEq + 'n> PartialEq for TreeCursor<'n, 'f, N>

fn eq(&self, other: &TreeCursor<'n, 'f, N>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'n: 'f, 'f, N: Eq + 'n> Eq for TreeCursor<'n, 'f, N>

impl<'n: 'f, 'f, N: 'n> StructuralPartialEq for TreeCursor<'n, 'f, N>