Struct lz_eytzinger_tree::Node

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

Represents a borrowed node in the Eytzinger tree. This node may be used to navigate to parent or child nodes.

Methods

impl<'a, N> Node<'a, N>

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

Gets the Eytzinger tree this node is for.

Examples

use lz_eytzinger_tree::{EytzingerTree, Node};

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

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

pub fn value(&self) -> &'a N

Gets the value stored at this node.

Examples

use lz_eytzinger_tree::{EytzingerTree, Node};

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

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

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

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

Examples

use lz_eytzinger_tree::{EytzingerTree, Node};

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

let root = tree.root().unwrap();
let child = root.child(2).unwrap();
assert_eq!(child.parent(), Some(root));

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

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

Examples

use lz_eytzinger_tree::{EytzingerTree, Node};

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

let root = tree.root().unwrap();
let child = root.child(2).unwrap();
assert_eq!(child.value(), &3);

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<'a, 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 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().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<'a, 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<'a, N>

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

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: Eq> Eq for Node<'a, N> where     N: 'a,

impl<'a, N> Copy for Node<'a, N>

impl<'a, N: PartialEq> PartialEq<Node<'a, N>> for Node<'a, N> where     N: 'a,

fn eq(&self, other: &Node<'a, N>) -> bool

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

fn ne(&self, other: &Node<'a, N>) -> bool

This method tests for !=.

impl<'a, N> Clone for Node<'a, N>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

type Target = N

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a, N: Hash> Hash for Node<'a, N> where     N: 'a,

fn hash<__HN: Hasher>(&self, state: &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].