concread 0.5.10

Concurrently Readable Data-Structures for Rust
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

use crate::internals::bptree::cursor::{CursorRead, CursorWrite, SuperBlock};
use crate::internals::lincowcell::{LinCowCell, LinCowCellCapable};

struct TestStruct {
    bptree_map_a: SuperBlock<u32, u32>,
    bptree_map_b: SuperBlock<u32, u32>,
}

struct TestStructRead {
    bptree_map_a: CursorRead<u32, u32>,
    bptree_map_b: CursorRead<u32, u32>,
}

struct TestStructWrite {
    bptree_map_a: CursorWrite<u32, u32>,
    bptree_map_b: CursorWrite<u32, u32>,
}

impl LinCowCellCapable<TestStructRead, TestStructWrite> for TestStruct {
    fn create_reader(&self) -> TestStructRead {
        // This sets up the first reader.
        TestStructRead {
            bptree_map_a: self.bptree_map_a.create_reader(),
            bptree_map_b: self.bptree_map_b.create_reader(),
        }
    }

    fn create_writer(&self) -> TestStructWrite {
        // This sets up the first writer.
        TestStructWrite {
            bptree_map_a: self.bptree_map_a.create_writer(),
            bptree_map_b: self.bptree_map_b.create_writer(),
        }
    }

    fn pre_commit(&mut self, new: TestStructWrite, prev: &TestStructRead) -> TestStructRead {
        let TestStructWrite {
            bptree_map_a,
            bptree_map_b,
        } = new;

        let bptree_map_a = self
            .bptree_map_a
            .pre_commit(bptree_map_a, &prev.bptree_map_a);

        let bptree_map_b = self
            .bptree_map_b
            .pre_commit(bptree_map_b, &prev.bptree_map_b);

        TestStructRead {
            bptree_map_a,
            bptree_map_b,
        }
    }
}

#[test]
fn test_lc_basic() {
    let lcc = LinCowCell::new(TestStruct {
        bptree_map_a: unsafe { SuperBlock::new() },
        bptree_map_b: unsafe { SuperBlock::new() },
    });

    let x = lcc.write();

    x.commit();

    let _r = lcc.read();
}