Struct Node

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

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

Implementations

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);

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]);

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

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

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

where N: 'a + Debug,

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> From<&'a NodeMut<'a, N>> for Node<'a, N>

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

where N: 'a + Hash,

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<'a, N> PartialEq for Node<'a, N>

where N: 'a + PartialEq,

fn eq(&self, other: &Node<'a, 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<'a, N> Copy for Node<'a, N>

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

where N: 'a + Eq,

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

where N: 'a,