Struct lz_eytzinger_tree::NodeMut

pub struct NodeMut<'a, N> where
    N: 'a,  { /* fields omitted */ }

Represents a borrowed node in the Eytzinger tree. This node may be used mutate this node's value and child nodes.

Methods

impl<'a, N> NodeMut<'a, N>

pub fn tree(&self) -> &EytzingerTree<N>

Gets the Eytzinger tree this node is for.

pub fn value(&self) -> &N

Gets the value stored at this node.

Examples

use lz_eytzinger_tree::{EytzingerTree, Node};

let mut tree = {
    let mut tree = EytzingerTree::<u32>::new(8);
    tree.set_root_value(5);
    tree
};

let root = tree.root_mut().unwrap();
assert_eq!(root.value(), &5);

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

Gets the mutable value stored at this node.

Examples

use lz_eytzinger_tree::{EytzingerTree, Node};

let mut tree = {
    let mut tree = EytzingerTree::<u32>::new(8);
    tree.set_root_value(5);
    tree
};

let mut root = tree.root_mut().unwrap();
*root.value_mut() = 8;
assert_eq!(root.value(), &8);

pub fn into_value_mut(self) -> &'a mut N

Gets the mutable value stored at this node.

This differs from value_mut in that it takes ownership of the current node and the value is lifetime bound to the tree and not to the current node.

pub fn parent(&self) -> Option<Node<N>>

Gets the parent of this node or None is there was none.

pub fn to_parent(self) -> Result<Self, Self>

Gets the mutable paret of this node or None if there wasn't one.

This differs from parent_mut in that it takes ownership of the current node and is lifetime bound to the tree and not to the current node.

pub fn child(&self, index: usize) -> Option<Node<N>>

Gets the child of this node at the specified index or None if there wasn't one.

pub fn child_mut(&mut self, index: usize) -> Option<NodeMut<N>>

Gets the mutable child of this node at the specified index or None if there wasn't one.

pub fn to_child(self, index: usize) -> Result<Self, Self>

Gets the mutable child of this node at the specified index or None if there wasn't one.

This differs from child_mut in that it takes ownership of the current node and is lifetime bound to the tree and not to the current node.

pub fn set_child_value(&mut self, index: usize, new_value: N) -> NodeMut<N>

Sets the value of the child at the specified index.

Returns

The new mutable child.

pub fn remove_child_value(     &mut self,     index: usize ) -> (Option<N>, VacantEntry<N>)

Removes the child value at the specified child index. This will also remove all children of the specified child.

Returns

The old child value if there was one.

pub fn child_entry(&mut self, index: usize) -> Entry<N>

Gets the child entry of this node at the specified index. This node is not consumed in the process so the child entry is lifetime bound to this node.

pub fn to_child_entry(self, index: usize) -> Entry<'a, N>

Gets the child entry of this node at the specified index.

This differs from child_entry in that it takes ownership of the current node and the entry is lifetime bound to the tree and not to the current node.

pub fn remove(self) -> (N, VacantEntry<'a, N>)

Removes this node from the tree.

Examples

use lz_eytzinger_tree::{EytzingerTree, Node};

let mut tree = {
    let mut tree = EytzingerTree::<u32>::new(8);
    tree.set_root_value(5);
    tree
};
{
    let mut root = tree.root_mut().unwrap();
    root.remove();
}
assert_eq!(tree.root(), None);

pub fn as_node(&self) -> Node<N>

Gets a view of this mutable node as an immutable node. The resulting node is lifetime bound to this node so the immutable node may not outlive this mutable node.

Important traits for NodeChildIter<'a, N>

impl<'a, N> Iterator for NodeChildIter<'a, N> type Item = Node<'a, N>;

pub fn child_iter(&self) -> NodeChildIter<N>

Gets an iterator over the immediate children of this node. This only includes children for which there is a node.

Examples

use lz_eytzinger_tree::{EytzingerTree, Node};

let mut tree = {
    let mut tree = EytzingerTree::<u32>::new(8);
    {
        let mut root = tree.set_root_value(5);
        root.set_child_value(0, 1);
        root.set_child_value(2, 3);

    }
    tree
};

let root = tree.root_mut().unwrap();
let child_values: Vec<_> = root.child_iter().map(|n| n.value()).collect();
assert_eq!(child_values, vec![&1, &3]);

Important traits for DepthFirstIter<'a, N>

impl<'a, N> Iterator for DepthFirstIter<'a, N> type Item = Node<'a, N>;

pub fn depth_first_iter(&self, order: DepthFirstOrder) -> DepthFirstIter<N>

Gets a depth-first iterator over this and all child nodes.

Important traits for BreadthFirstIter<'a, N>

impl<'a, N> Iterator for BreadthFirstIter<'a, N> type Item = Node<'a, N>;

pub fn breadth_first_iter(&self) -> BreadthFirstIter<N>

Gets a breadth-first iterator over this and all child nodes.

pub fn split_off(self) -> EytzingerTree<N>

Trait Implementations

impl<'a, N> From<NodeMut<'a, N>> for Node<'a, N>

fn from(value: NodeMut<'a, N>) -> Node<'a, N>

Performs the conversion.

impl<'a, N> From<&'a NodeMut<'a, N>> for Node<'a, N>

fn from(value: &'a NodeMut<'a, N>) -> Node<'a, N>

Performs the conversion.

impl<'a, N: Debug> Debug for NodeMut<'a, N> where     N: 'a,

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

Formats the value using the given formatter.

impl<'a, N> DerefMut for NodeMut<'a, N>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, N> Deref for NodeMut<'a, N>

type Target = N

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.