fast_forward 0.0.2

Quering collections blazing fast.
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use fast_forward::{
    collections::rw::IList,
    index::uint::UIntIndex,
    index::{indices::Indices, store::Filterable, view::Filter, Indexable},
};

trait Parents<'a> {
    fn parents(&self, key: usize, stop: usize) -> Indices<'a>;
}

impl<'a, F, L> Parents<'a> for Filter<'a, F, L>
where
    F: Filterable<Key = usize, Index = usize>,
    L: Indexable<usize, Output = Node>,
{
    fn parents(&self, key: usize, stop: usize) -> Indices<'a> {
        let mut result = Indices::empty();

        if key == stop {
            return result;
        }

        for n in self.items(&key) {
            result = self.eq(&n.parent) | self.parents(n.parent, stop);
        }

        result
    }
}

#[derive(Debug, PartialEq)]
struct Node {
    id: usize,
    parent: usize,
}

impl Node {
    fn new(id: usize, parent: usize) -> Self {
        Self { id, parent }
    }
}

fn main() {
    //
    //         0
    //       1   4
    //     2   3
    //   5
    // 6
    let nodes = vec![
        Node::new(0, 0),
        Node::new(1, 0),
        Node::new(2, 1),
        Node::new(3, 1),
        Node::new(4, 0),
        Node::new(5, 2),
        Node::new(6, 5),
    ];

    let n = IList::<UIntIndex, _, _>::from_iter(|n: &Node| n.id, nodes.into_iter());

    // PARENTS: up to the root node
    assert_eq!(None, n.idx().filter(|f| f.parents(9, 0)).next());
    assert_eq!(None, n.idx().filter(|f| f.parents(0, 0)).next());

    assert_eq!(
        vec![&Node::new(0, 0)],
        n.idx().filter(|f| f.parents(1, 0)).collect::<Vec<_>>()
    );
    assert_eq!(
        vec![&Node::new(0, 0)],
        n.idx().filter(|f| f.parents(4, 0)).collect::<Vec<_>>()
    );
    assert_eq!(
        vec![&Node::new(0, 0), &Node::new(1, 0)],
        n.idx().filter(|f| f.parents(2, 0)).collect::<Vec<_>>()
    );
    assert_eq!(
        vec![&Node::new(0, 0), &Node::new(1, 0)],
        n.idx().filter(|f| f.parents(3, 0)).collect::<Vec<_>>()
    );
    assert_eq!(
        vec![&Node::new(0, 0), &Node::new(1, 0), &Node::new(2, 1)],
        n.idx().filter(|f| f.parents(5, 0)).collect::<Vec<_>>()
    );
    assert_eq!(
        vec![
            &Node::new(0, 0),
            &Node::new(1, 0),
            &Node::new(2, 1),
            &Node::new(5, 2)
        ],
        n.idx().filter(|f| f.parents(6, 0)).collect::<Vec<_>>()
    );

    // // PARENTS-SUBTREE: NOT up to the root node
    assert_eq!(
        vec![&Node::new(2, 1), &Node::new(5, 2)],
        n.idx().filter(|f| f.parents(6, 2)).collect::<Vec<_>>()
    );
}