orx-tree 2.2.0

A beautiful tree 🌳 with convenient, efficient, parallelizable growth, mutation and traversal features.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use crate::Node;
use crate::TreeVariant;
use crate::aliases::Col;
use crate::memory::{Auto, MemoryPolicy};
use crate::pinned_storage::{PinnedStorage, SplitRecursive};
use orx_selfref_col::NodePtr;

pub trait NodeItem<'a, V, M = Auto, P = SplitRecursive>
where
    V: TreeVariant,
    M: MemoryPolicy,
    P: PinnedStorage,
{
    fn from_ptr(col: &'a Col<V, M, P>, node_ptr: NodePtr<V>) -> Self;

    fn node_data(&self) -> &V::Item;
}

impl<'a, V, M, P> NodeItem<'a, V, M, P> for Node<'a, V, M, P>
where
    V: TreeVariant,
    M: MemoryPolicy,
    P: PinnedStorage,
{
    #[inline(always)]
    fn from_ptr(col: &'a Col<V, M, P>, node_ptr: NodePtr<V>) -> Self {
        Node::new(col, node_ptr)
    }

    #[inline(always)]
    fn node_data(&self) -> &V::Item {
        use crate::NodeRef;
        self.data()
    }
}

impl<'a, V, M, P> NodeItem<'a, V, M, P> for &'a V::Item
where
    V: TreeVariant,
    M: MemoryPolicy,
    P: PinnedStorage,
{
    #[inline(always)]
    fn from_ptr(_: &'a Col<V, M, P>, node_ptr: NodePtr<V>) -> Self {
        let node = unsafe { &*node_ptr.ptr() };
        node.data().expect("active tree node has data")
    }

    #[inline(always)]
    fn node_data(&self) -> &V::Item {
        self
    }
}

impl<'a, V, M, P> NodeItem<'a, V, M, P> for NodePtr<V>
where
    V: TreeVariant,
    M: MemoryPolicy,
    P: PinnedStorage,
{
    #[inline(always)]
    fn from_ptr(_: &'a Col<V, M, P>, node_ptr: NodePtr<V>) -> Self {
        node_ptr
    }

    #[inline(always)]
    fn node_data(&self) -> &V::Item {
        unsafe { &*self.ptr() }
            .data()
            .expect("active tree node has data")
    }
}