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

use std::mem;

use o3::mem::{Lease, Return, lease::Open};

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

/// Exact reason a standalone fixed-file slot could not be reserved.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Error {
    Capacity { available: u32 },
    Retiring { available: u32 },
}

#[must_use = "a fixed-file slot reservation must be installed or returned"]
pub(crate) struct Reserved<'d> {
    inner: Lease<Release<'d>, Open>,
}

struct Release<'d> {
    driver: driver::Reference<'d>,
}

impl<'d> Return for Release<'d> {
    type Item = domain::Solo<identity::Identity<'d>>;

    fn return_item(self, slot: Self::Item) {
        let (identity, solo) = slot.release();
        let domain = self.driver.descriptors().domain();
        domain.release(identity);
        domain::Outbound::from(domain).release_one(solo);
    }
}

impl<'d> Reserved<'d> {
    pub(crate) fn try_new(driver: driver::Reference<'d>) -> Result<Self, Error> {
        let solo = domain::Outbound::from(driver.descriptors().domain()).try_reserve()?;
        Ok(Self {
            inner: Lease::open(Release { driver }, solo),
        })
    }

    pub(crate) fn slot(&self) -> &domain::Solo<identity::Identity<'d>> {
        self.inner.item()
    }

    pub(crate) fn commit(self) -> (driver::Reference<'d>, domain::Solo<identity::Identity<'d>>) {
        let (release, slot) = self.inner.into_parts();
        (release.driver, slot)
    }
}

const _: () = {
    assert!(mem::size_of::<Result<Reserved<'static>, Error>>() == 2 * mem::size_of::<usize>());
    assert!(mem::size_of::<Reserved<'static>>() == 2 * mem::size_of::<usize>());
    assert!(mem::align_of::<Reserved<'static>>() == mem::align_of::<usize>());
};