dope-core 0.29.1

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

use std::mem;

use crate::{
    driver,
    driver::route,
    io::fd::{domain, domain::retire, handles, identity},
};

#[derive(Clone, Copy)]
#[repr(transparent)]
pub(crate) struct Access<'d>(driver::Reference<'d>);

impl<'d> Access<'d> {
    pub(crate) const fn new(driver: driver::Reference<'d>) -> Self {
        Self(driver)
    }

    pub(crate) fn retire(self, id: identity::Identity<'d>) {
        let arena = self.0.ready().arena();
        arena.descriptors().retire().retire(id);
        arena.unqueue_fd(&id);
    }

    pub(crate) fn unopened(self, id: identity::Identity<'d, handles::OutboundSlot>) {
        let arena = self.0.ready().arena();
        arena.descriptors().retire().unopened(id);
        arena.unqueue_fd(&id);
    }

    pub(crate) fn creating(self, id: identity::Identity<'d, handles::OutboundSlot>) {
        let arena = self.0.ready().arena();
        arena.descriptors().retire().creating(id);
        arena.unqueue_fd(&id);
    }

    pub(crate) fn set_target(self, id: identity::Identity<'d>, target: route::Token) {
        self.0.ready().arena().descriptors().set_target(id, target);
    }

    pub(crate) fn target(self, id: identity::Identity<'d>) -> Option<route::Token> {
        self.domain().target(id)
    }

    pub(crate) fn abandon(self, accepted: handles::Accepted) -> handles::Reclaimed {
        self.0.ready().arena().unqueue_fd(&accepted);
        self.domain().retire().abandon(accepted)
    }

    pub(crate) fn discard(self, slot: handles::OutboundSlot) {
        self.0.ready().arena().unqueue_fd(&slot);
        self.domain().retire().discard(slot);
    }

    pub(crate) fn retirement(self) -> retire::View<'d> {
        self.domain().retire()
    }

    pub(crate) fn domain(self) -> &'d domain::Domain {
        self.0.ready().arena().descriptors()
    }
}

const _: () = {
    assert!(mem::size_of::<Access<'_>>() == mem::size_of::<driver::Reference<'_>>());
    assert!(mem::align_of::<Access<'_>>() == mem::align_of::<driver::Reference<'_>>());
};