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

use contiguous_mem::prelude::*;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Data {
    value: u32,
}

fn main() {
    let storage = SyncContiguousMemory::new(4096);

    let mut sent_storage = storage.clone();
    let writer_one =
        std::thread::spawn(move || sent_storage.store(22u64).expect("unable to store number"));

    let data = Data { value: 42 };

    let mut sent_storage = storage.clone();
    let writer_two = std::thread::spawn(move || {
        sent_storage
            .store(Data { value: 42 })
            .expect("unable to store Data")
    });

    let stored_number: SyncContiguousMemoryRef<u64> =
        writer_one.join().expect("unable to join number thread");
    let mut stored_number_clone = stored_number.clone();
    let stored_data: SyncContiguousMemoryRef<Data> =
        writer_two.join().expect("unable to join Data thread");

    let number_ref = stored_number
        .get()
        .expect("number ref poisoned on first use");
    let stored_data = stored_data.get().expect("Data ref poisoned on first use");

    // note that number is still locked here
    assert!(
        stored_number_clone.try_get_mut().is_err(),
        "number reference should not be writable as the number is currently borrowed"
    );

    assert_eq!(*number_ref, 22);
    assert_eq!(*stored_data, data);
}