Struct Node

pub struct Node<'a, V, M = Auto, P = SplitRecursive>
where
    V: TreeVariant,
    M: MemoryPolicy,
    P: PinnedStorage,
{ /* private fields */ }

A node of the tree.

Trait Implementations

impl<V, M, P> Clone for Node<'_, V, M, P>

where V: TreeVariant, M: MemoryPolicy, P: PinnedStorage,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V, M, P> Debug for Node<'_, V, M, P>

where V: TreeVariant, M: MemoryPolicy, P: PinnedStorage, V::Item: Debug,

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

Formats the value using the given formatter.

impl<V, M, P> Display for Node<'_, V, M, P>

where V: TreeVariant, M: MemoryPolicy, P: PinnedStorage, V::Item: Display,

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

Creates a convenient-to-read string representation of the tree or a subtree rooted at a node.

Examples

use orx_tree::*;

//      1
//     ╱ ╲
//    ╱   ╲
//   2     3
//  ╱ ╲   ╱ ╲
// 4   5 6   7
// |     |  ╱ ╲
// 8     9 10  11

let mut tree = DynTree::new(1);

let mut root = tree.root_mut();
let [id2, id3] = root.push_children([2, 3]);
let [id4, _] = tree.node_mut(&id2).push_children([4, 5]);
tree.node_mut(&id4).push_child(8);
let [id6, id7] = tree.node_mut(&id3).push_children([6, 7]);
tree.node_mut(&id6).push_child(9);
tree.node_mut(&id7).push_children([10, 11]);

let expected_str = r#"1
├──2
│  ├──4
│  │  └──8
│  └──5
└──3
   ├──6
   │  └──9
   └──7
      ├──10
      └──11
"#;
assert_eq!(tree.to_string(), expected_str);

let expected_str = r#"3
├──6
│  └──9
└──7
   ├──10
   └──11
"#;
println!("{}", tree.node(&id3).to_string());
assert_eq!(tree.node(&id3).to_string(), expected_str);

impl<'a, V, M, P> PartialEq<Node<'a, V, M, P>> for NodeMut<'_, V, M, P>

where V: TreeVariant, M: MemoryPolicy, P: PinnedStorage,

fn eq(&self, other: &Node<'a, V, M, P>) -> 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, V, M, P> PartialEq<NodeMut<'a, V, M, P>> for Node<'_, V, M, P>

where V: TreeVariant, M: MemoryPolicy, P: PinnedStorage,

fn eq(&self, other: &NodeMut<'a, V, M, P>) -> 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<V, M, P> PartialEq for Node<'_, V, M, P>

where V: TreeVariant, M: MemoryPolicy, P: PinnedStorage,

fn eq(&self, other: &Self) -> 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<V, M, P> Send for Node<'_, V, M, P>

where V: TreeVariant, M: MemoryPolicy, P: PinnedStorage, V::Item: Send,

impl<V, M, P> Sync for Node<'_, V, M, P>

where V: TreeVariant, M: MemoryPolicy, P: PinnedStorage, V::Item: Sync,