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

pub mod storage;
pub use storage::Reject as Error;

use std::mem;

use o3::depot::queue::resident;

use crate::{
    driver,
    driver::schedule::{
        app,
        ready::{self, wake, wake::resident::drain},
    },
};

/// Linear ownership of one persistent subscription slot.
#[repr(transparent)]
pub struct Registration<'target, 'd: 'target> {
    inner: storage::Lease<'target, ready::Retained<'d>>,
}

/// Fixed-capacity set of persistent wake subscriptions.
pub struct Set<'d> {
    driver: driver::Reference<'d>,
    inner: storage::Registry<ready::Retained<'d>>,
}

impl<'d> Set<'d> {
    pub fn try_new(
        driver: driver::Reference<'d>,
        capacity: usize,
    ) -> Result<Self, resident::Error> {
        Ok(Self {
            driver,
            inner: storage::Registry::try_new(capacity)?,
        })
    }

    pub fn try_register<'target>(
        &'target self,
        lease: &mut Registration<'target, 'd>,
        wake: &wake::Waker<'d>,
    ) -> Result<(), Error> {
        self.inner.try_keep(&mut lease.inner, *wake.key())
    }

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

    pub fn has_pending(&self) -> bool {
        self.inner.has_pending()
    }

    pub fn drain_one(&self, work: app::Work<'_, 'd>) -> wake::Drain {
        drain::one(
            self.driver,
            work,
            || self.inner.has_pending(),
            || self.inner.step(),
        )
    }
}

impl Default for Registration<'_, '_> {
    fn default() -> Self {
        Self::new()
    }
}

impl Registration<'_, '_> {
    pub const fn new() -> Self {
        Self {
            inner: storage::Lease::new(),
        }
    }

    pub fn clear(&mut self) {
        *self = Self::new();
    }
}

const _: () = {
    assert!(mem::size_of::<Registration<'static, 'static>>() == 2 * mem::size_of::<usize>());
    assert!(mem::align_of::<Registration<'static, 'static>>() == mem::align_of::<usize>());
    assert!(
        mem::size_of::<Set<'static>>()
            == mem::size_of::<(
                driver::Reference<'static>,
                storage::Registry<ready::Retained<'static>>,
            )>()
    );
};