dope-sys 0.43.0

Typed operating-system call contracts
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

use std::time;

use crate::{
    Errno,
    table::change::{Filter, Index},
};

mod backend;
pub mod delivery;
mod driver;
mod poll;
pub mod raw;
mod source;
pub mod store;

pub use backend::Backend;
pub use driver::Driver;
pub use poll::Poll;
pub use source::Source;

/// Readiness failures classified at the syscall or timeout validation boundary.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Cause {
    Timeout(time::Duration),
    Wait(Errno),
    Changes(Errno),
}

/// One syscall's bounded receipt storage, shared by its native input and output.
pub const RECEIPTS: usize = 64;

/// Every failure issued by one retirement attempt, in receipt order.
#[derive(Debug)]
pub struct Failures<F> {
    pub first: F,
    pub rest: [Option<F>; RECEIPTS - 1],
}

impl<F> From<F> for Failures<F> {
    fn from(first: F) -> Self {
        Self {
            first,
            rest: [const { None }; RECEIPTS - 1],
        }
    }
}

/// Exact readiness failure constructors retaining the caller's typed domains.
pub trait Failure: Copy + From<Cause> {
    type Index: Copy + Eq;
    type Missing: Copy + Eq;
    type Operation: Copy;

    fn revoke(fd: usize, filter: Filter, errno: Errno) -> Self;
    fn backing(error: Index<Self::Index>) -> Self;
    fn missing(op: Self::Operation, cause: Self::Missing) -> Self;
    fn system(op: Self::Operation, errno: Errno) -> Self;
}