kernel 1.1.0

Abstract Reactive Streams
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use std::fmt;
use std::fmt::Debug;
use handle;

#[derive(PartialEq, Debug)]
pub struct Node<'a> {
    pub bounds: (usize, usize),
    pub parent: Option<&'a Node<'a>>,
}


impl<'a> fmt::Display for Node<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self.parent {
            Some(parent) => write!(f, "[{:?}—{:?}]", self.bounds, parent.bounds),
            _ => write!(f, "[{:?}—(root)]", self.bounds),
        }
    }
}

#[derive(Debug)]
pub struct Tree<'a, T> {
    pub nodes: Vec<Node<'a>>,
    pub items: Vec<T>,
}

// TODO: Remove T: Debug
impl<'a, T: Debug> Tree<'a, T> {
    pub fn with_capacity(cap: usize) -> Self {
        let mut n = Vec::with_capacity(cap);
        n.push(Node {
            bounds: (0, 0),
            parent: None,
        });
        Tree {
            nodes: n,
            items: Vec::with_capacity(cap),
        }
    }

    pub fn len(&'a self) -> (usize, usize) {
        (self.nodes.len(), self.items.len())
    }

    pub fn dump(&'a self) {
        for i in self.items[0..self.items.len()].iter() {
            println!("item {:?}", i);
        }
        for i in self.nodes[0..self.nodes.len()].iter() {
            println!("node {}", i);
        }

    }

    #[inline]
    pub fn last_node(&'a self) -> &'a Node<'a> {
        self.nodes.last().unwrap()
    }

    #[inline]
    pub fn first_node(&'a self) -> &'a Node<'a> {
        self.nodes.first().unwrap()
    }

    pub fn append_node(&'a mut self, n: &'a Node<'a>) -> &'a Node<'a> {
        let (s1, s2) = handle::split(self);
        let nl = s1.last_node();
        s2.nodes.push(Node {
            bounds: (nl.bounds.1, nl.bounds.1),
            parent: Some(n),
        });
        s1.last_node()
    }

    pub fn alloc_node(&'a mut self) -> &'a Node<'a> {
        let (s1, s2) = handle::split(self);
        let n = s1.last_node();
        s2.nodes.push(Node {
            bounds: (n.bounds.1, n.bounds.1),
            parent: Some(n),
        });
        s1.last_node()
    }

    pub fn insert(&mut self, item: T) {
        self.items.push(item);
        let mut n = self.nodes.last_mut().unwrap();
        n.bounds.1 += 1;
    }

    pub fn get<F>(&'a self, n: &'a Node<'a>, mut f: F) -> Option<(&'a T, &'a Node<'a>)>
        where for<'r> F: FnMut(&'r &T) -> bool
    {
        for i in self.items[n.bounds.0..n.bounds.1].iter().rev() {
            if f(&i) {
                return Some((i, n));
            }
        }
        match n.parent {
            Some(p) => self.get(p, f),
            None => None,
        }
    }

    pub fn clean(&mut self) -> usize {
        let l = self.items.len();
        unsafe {
            self.items.set_len(0);
            self.nodes.set_len(0);
        }
        self.nodes.push(Node {
            bounds: (0, 0),
            parent: None,
        });
        l
    }
}