generational-box 0.5.6

A box backed by a generational runtime
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

use std::cell::{Ref, RefMut};

use generational_box::{
    AlreadyBorrowedError, AlreadyBorrowedMutError, AnyStorage, BorrowError, BorrowMutError,
    GenerationalBox, GenerationalRef, GenerationalRefMut, Owner, UnsyncStorage, ValueDroppedError,
};

#[track_caller]
fn read_at_location(
    value: GenerationalBox<i32>,
) -> (
    GenerationalRef<Ref<'static, i32>>,
    &'static std::panic::Location<'static>,
) {
    let location = std::panic::Location::caller();
    let read = value.read();
    (read, location)
}

#[track_caller]
fn write_at_location(
    value: GenerationalBox<i32>,
) -> (
    GenerationalRefMut<RefMut<'static, i32>>,
    &'static std::panic::Location<'static>,
) {
    let location = std::panic::Location::caller();
    let write = value.write();
    (write, location)
}

#[track_caller]
fn create_at_location(
    owner: &Owner,
) -> (GenerationalBox<i32>, &'static std::panic::Location<'static>) {
    let location = std::panic::Location::caller();
    let value = owner.insert(1);
    (value, location)
}

#[test]
fn read_while_writing_error() {
    let owner = UnsyncStorage::owner();
    let value = owner.insert(1);

    let (write, location) = write_at_location(value);

    assert_eq!(
        value.try_read().err(),
        Some(BorrowError::AlreadyBorrowedMut(
            AlreadyBorrowedMutError::new(location)
        ))
    );
    drop(write);
}

#[test]
fn read_after_dropped_error() {
    let owner = UnsyncStorage::owner();
    let (value, location) = create_at_location(&owner);
    drop(owner);
    assert_eq!(
        value.try_read().err(),
        Some(BorrowError::Dropped(ValueDroppedError::new(location)))
    );
}

#[test]
fn write_while_writing_error() {
    let owner = UnsyncStorage::owner();
    let value = owner.insert(1);

    let (write, location) = write_at_location(value);

    assert_eq!(
        value.try_write().err(),
        Some(BorrowMutError::AlreadyBorrowedMut(
            AlreadyBorrowedMutError::new(location)
        ))
    );
    drop(write);
}

#[test]
fn write_while_reading_error() {
    let owner = UnsyncStorage::owner();
    let value = owner.insert(1);

    let (read, location) = read_at_location(value);

    assert_eq!(
        value.try_write().err(),
        Some(BorrowMutError::AlreadyBorrowed(AlreadyBorrowedError::new(
            vec![location]
        )))
    );

    drop(read);
}