dope-core 0.26.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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::{mem, os::fd};

const _: () = assert!(mem::size_of::<Result<(), Errno>>() == mem::size_of::<i32>());

use crate::{
    Errno, driver,
    driver::{route, route::kind},
    io::{
        Event, event,
        event::{
            batch::Flow,
            file::{open, read, sync, write},
            net::{accept, connect, recv, send, socket},
        },
        fd::handles::{self, Accepted, Created},
        recv::Lease,
        socket::Create,
        transfer,
    },
};

pub(crate) const fn shutdown<'d>() -> Event<'d> {
    Event(event::Kind::Shutdown)
}

pub(crate) fn accepted<'d>(
    token: route::Erased<'d, kind::Accept>,
    accepted: Accepted,
    flow: Flow,
    driver: driver::Reference<'d>,
) -> Event<'d> {
    let outcome = match accepted.bind(driver) {
        handles::Admission::Ready(accepted) => accept::Outcome::Accepted(accepted),
        handles::Admission::Retired(retired) => accept::Outcome::Failed(retired.into()),
    };
    Event(event::Kind::Accept(accept::Completion::new(
        token, flow, outcome,
    )))
}

pub(crate) fn accept_error<'d>(
    token: route::Erased<'d, kind::Accept>,
    failure: impl Into<accept::Failure>,
    flow: Flow,
) -> Event<'d> {
    Event(event::Kind::Accept(accept::Completion::new(
        token,
        flow,
        accept::Outcome::Failed(failure.into()),
    )))
}

pub(crate) fn opened<'d>(token: route::Erased<'d, kind::Open>, opened: fd::OwnedFd) -> Event<'d> {
    Event(event::Kind::Open(open::Completion::new(
        token,
        open::Outcome::Opened(opened),
    )))
}

pub(crate) fn open_failed<'d>(token: route::Erased<'d, kind::Open>, errno: Errno) -> Event<'d> {
    Event(event::Kind::Open(open::Completion::new(
        token,
        open::Outcome::Failed(errno),
    )))
}

pub(crate) fn socket<'d>(
    token: route::Erased<'d, kind::Socket>,
    created: Created<'d>,
    driver: driver::Reference<'d>,
) -> Event<'d> {
    Event(event::Kind::Socket(socket::Completion::new(
        token,
        socket::Outcome::Created(created.bind(driver)),
    )))
}

pub(crate) fn socket_gone<'d>(token: route::Erased<'d, kind::Socket>) -> Event<'d> {
    Event(event::Kind::Socket(socket::Completion::new(
        token,
        socket::Outcome::Failed(socket::Failure::Retired),
    )))
}

pub(crate) fn socket_error<'d>(token: route::Erased<'d, kind::Socket>, error: Create) -> Event<'d> {
    Event(event::Kind::Socket(socket::Completion::new(
        token,
        socket::Outcome::Failed(socket::Failure::Create(error)),
    )))
}

pub(crate) fn selected<'d>(
    token: route::Erased<'d, kind::Recv>,
    flow: Flow,
    buffer: Lease<'d>,
) -> Event<'d> {
    Event(event::Kind::Recv(recv::Completion::new(
        token,
        flow,
        recv::Outcome::Data(buffer),
    )))
}

pub(crate) fn sent<'d>(
    token: route::Erased<'d, kind::Send>,
    outcome: Result<transfer::Len, Errno>,
) -> Event<'d> {
    Event(event::Kind::Send(send::Completion::new(token, outcome)))
}

pub(crate) fn connected<'d>(
    token: route::Erased<'d, kind::Connect>,
    outcome: Result<(), connect::Error>,
) -> Event<'d> {
    Event(event::Kind::Connect(connect::Completion::new(
        token, outcome,
    )))
}

pub(crate) fn written<'d>(
    token: route::Erased<'d, kind::Write>,
    outcome: Result<transfer::Len, Errno>,
) -> Event<'d> {
    Event(event::Kind::Write(write::Completion::new(token, outcome)))
}

pub(crate) fn read<'d>(
    token: route::Erased<'d, kind::Read>,
    outcome: Result<transfer::Len, Errno>,
) -> Event<'d> {
    Event(event::Kind::Read(read::Completion::new(token, outcome)))
}

pub(crate) fn synced<'d>(
    token: route::Erased<'d, kind::Sync>,
    outcome: Result<(), Errno>,
) -> Event<'d> {
    Event(event::Kind::Sync(sync::Completion::new(token, outcome)))
}