dope-core 0.20.0

Owned native I/O and completion driver for dope
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

use o3::{
    depot::arena::slab::{entries, external},
    mem,
    mem::lease,
};

use crate::driver::{route, route::table};

type Insertion<'a, T, Tag> = external::Staged<
    mem::Lease<
        entries::Busy<
            'a,
            external::Stamped<T, route::Epoch>,
            { u32::MAX },
            entries::Exclusive<true>,
            { table::PARTITIONS },
        >,
        lease::Open,
    >,
    Tag,
    true,
    external::Logical,
>;

#[repr(transparent)]
pub struct Entry<'a, T, Tag: route::Tag> {
    inner: external::Vacant<
        entries::Pending<
            'a,
            external::Stamped<T, route::Epoch>,
            { u32::MAX },
            entries::Exclusive<true>,
            { table::PARTITIONS },
        >,
        Tag,
        true,
        route::Epoch,
    >,
}

impl<'a, T, Tag: route::Tag> Entry<'a, T, Tag> {
    pub(in crate::driver::route::table) fn new(
        inner: external::Vacant<
            entries::Pending<
                'a,
                external::Stamped<T, route::Epoch>,
                { u32::MAX },
                entries::Exclusive<true>,
                { table::PARTITIONS },
            >,
            Tag,
            true,
            route::Epoch,
        >,
    ) -> Self {
        Self { inner }
    }

    pub fn insert(self, value: T) {
        self.inner.commit(value);
    }

    pub fn stage(self, value: T) -> Staged<'a, T, Tag> {
        Staged::new(self.inner.stage(value))
    }

    pub fn key(&self) -> table::Key<Tag> {
        table::Key::new(self.inner.key())
    }
}

#[repr(transparent)]
pub struct Staged<'a, T, Tag: route::Tag> {
    inner: Insertion<'a, T, Tag>,
}

impl<'a, T, Tag: route::Tag> Staged<'a, T, Tag> {
    pub(in crate::driver::route::table) fn new(inner: Insertion<'a, T, Tag>) -> Self {
        Self { inner }
    }

    pub fn get_mut(&mut self) -> &mut T {
        self.inner.get_mut()
    }

    pub fn publish(self) {
        self.inner.publish();
    }

    pub fn reject(self) -> T {
        self.inner.reject()
    }
}