bump_recycle 0.1.0

Bump allocator that can reuse deallocated memory.
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

#![feature(allocator_api)]

pub mod graph{
    use std::{rc::Rc};
    use bump_recycle::ReBump;

    pub struct Node{
        out: Vec<usize/* node index */, Rc<ReBump>>
    }
    impl Node{
        pub fn out(&self) -> &[usize]{
            &self.out
        }
        pub fn push_out(&mut self, idx: usize){
            self.out.push(idx);
        }
    }

    pub struct Graph{
        nodes: Vec<Node, Rc<ReBump>>
    }

    // Rc prevents us from being Send safe.
    // But, Rc<ReBump> is inaccessible from outside, and ReBump is Send safe.
    // It is impossible to change Rc counters, or access it's containment
    // from different threads.
    unsafe impl Send for Graph{}

    impl Graph{
        pub fn new() -> Graph{
            Graph{
                nodes: Vec::new_in(Default::default()),
            }
        }

        pub fn nodes(&self) -> &[Node] {
            &self.nodes
        }

        pub fn nodes_mut(&mut self) -> &mut [Node] {
            &mut self.nodes
        }

        pub fn push_node(&mut self) -> usize {
            let allocator = self.nodes.allocator().clone();
            let idx = self.nodes.len();
            self.nodes.push(Node{
                out: Vec::new_in(allocator),
            });
            idx
        }
    }
}

fn main(){
    use graph::*;
    let mut graph = Graph::new();
    let n0_idx = graph.push_node();
    let n1_idx = graph.push_node();
    graph.nodes_mut()[n0_idx].push_out(n1_idx);
}