dope-core 0.34.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

use dope_sys::io::socket::addr::{Length, Storage};

use crate::{
    driver,
    driver::{
        flight, retained,
        retained::{accept, arm},
        route,
        route::kind,
    },
    io::fd::handles,
};

#[must_use]
pub struct Arming<'a, 'd, Tag>
where
    Tag: route::Tag<Class = kind::Accept>,
{
    entry: accept::Entry<'a, 'd, Tag>,
}

impl<'a, 'd, Tag> Arming<'a, 'd, Tag>
where
    Tag: route::Tag<Class = kind::Accept>,
{
    pub(super) fn new(entry: accept::Entry<'a, 'd, Tag>) -> Self {
        Self { entry }
    }

    /// Defers admission until prior descriptor retirements return.
    /// # Safety
    /// `fd` and `slots` belong to `driver`. Retain this pinned lane and descriptor
    /// through terminal completion or quiescence.
    pub unsafe fn submit(
        mut self,
        driver: &mut driver::Context<'_, 'd>,
        slots: &flight::Slots<'d, Tag>,
        fd: &handles::Descriptor<'d>,
    ) -> arm::Submission
    where
        'd: 'a,
    {
        if !matches!(
            accept::Readiness::from(driver.driver_ref()),
            accept::Readiness::Ready
        ) {
            return arm::Submission::Deferred;
        }
        let lane = self.entry.lane.as_mut().project();
        let peer = lane.addr.get_mut();
        *peer = Storage::<Length>::empty();
        let closed = driver.driver_ref().descriptors().retirement().completed();
        let request = retained::raw::Submission::accept(fd, peer, lane.state.operation());
        // SAFETY: the caller retains this exact pinned lane through terminal
        // completion or owner quiescence.
        let flight = unsafe { request.try_submit(driver.reborrow(), slots) };
        self.entry.apply(flight, closed)
    }
}