dope-runtime 0.20.0

Thread-per-core execution and process lifecycle 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

use std::{mem, ops, pin};

use dope_core::{
    driver::{retained, route::Route, schedule},
    io,
};

use crate::executor;

/// Event dispatch authority for one exact retained root and scheduler turn.
#[must_use]
pub struct Dispatch<'app, 'driver, 'turn, 'root, 'd: 'root, R> {
    app: pin::Pin<&'app mut R>,
    drive: executor::raw::Drive<'driver, 'turn, 'root, 'd>,
    event: io::Event<'d>,
}

impl<'app, 'driver, 'turn, 'root, 'd: 'root, R> Dispatch<'app, 'driver, 'turn, 'root, 'd, R> {
    /// Binds one event to its exact pinned root and retained driver authority.
    pub const fn new(
        app: pin::Pin<&'app mut R>,
        event: io::Event<'d>,
        turn: schedule::Turn<'turn, 'd>,
        driver: retained::Context<'driver, 'root, 'd>,
    ) -> Self {
        Self {
            app,
            drive: executor::raw::Drive::new(turn, driver),
            event,
        }
    }

    pub fn route(&self) -> Route {
        self.event.route()
    }

    pub fn map(
        mut self,
        map: impl FnOnce(
            pin::Pin<&mut R>,
            io::Event<'d>,
            schedule::Turn<'_, 'd>,
            retained::Context<'_, 'root, 'd>,
        ) -> ops::ControlFlow<io::Event<'d>>,
    ) -> ops::ControlFlow<Self> {
        let (turn, driver) = self.drive.reborrow().into_parts();
        match map(self.app.as_mut(), self.event, turn, driver) {
            ops::ControlFlow::Continue(()) => ops::ControlFlow::Continue(()),
            ops::ControlFlow::Break(event) => {
                self.event = event;
                ops::ControlFlow::Break(self)
            }
        }
    }

    pub fn into_event(self) -> io::Event<'d> {
        self.event
    }

    pub fn into_parts(self) -> (pin::Pin<&'app mut R>, io::Event<'d>) {
        (self.app, self.event)
    }
}

const fn assert_layout() {
    type Call<'a> = Dispatch<'a, 'a, 'a, 'a, 'a, ()>;
    type Drive<'a> = executor::raw::Drive<'a, 'a, 'a, 'a>;

    assert!(
        mem::size_of::<Call<'static>>()
            == mem::size_of::<Drive<'static>>()
                + mem::size_of::<io::Event<'static>>()
                + mem::size_of::<pin::Pin<&'static mut ()>>()
    );
    assert!(mem::align_of::<Call<'static>>() == mem::align_of::<usize>());
}

const _: () = assert_layout();