dope-manifold 0.36.0

Owned application and service composition for dope
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

use std::task;

use dope_core::driver::{
    self, route,
    route::{Identity, indices},
    schedule::{
        clock::{self, timer},
        ready,
        ready::wake,
    },
};

use crate::app::creation;

pub(crate) struct Timer<'d, ID: Identity> {
    alarm: timer::Alarm<'d>,
    ready: ready::Slot<'d, ID>,
}

impl<'d, ID: Identity> Timer<'d, ID> {
    pub(crate) fn new(driver: &mut driver::Context<'_, 'd>) -> Result<Self, creation::Error> {
        let owner = driver.driver_ref();
        let target = owner
            .targets::<ID>()
            .bind(indices::SlotIndex::ZERO, route::Epoch::INITIAL);
        let ready = owner
            .ready()
            .make_slot(target.dispatch())
            .map_err(creation::Error::Ready)?;
        Ok(Self {
            alarm: driver
                .driver_ref()
                .timer()
                .try_alarm()
                .map_err(creation::Error::Timer)?,
            ready,
        })
    }

    pub(crate) fn poll(&self, now: clock::Moment<'d>) -> task::Poll<()> {
        let wake = wake::Waker::from(self.ready.target());
        self.alarm.poll(now, wake)
    }

    pub(crate) fn arm(&self, deadline: clock::Deadline<'d>) {
        let wake = wake::Waker::from(self.ready.target());
        self.alarm.arm(deadline, wake);
    }

    pub(crate) fn is_armed(&self) -> bool {
        self.alarm.is_armed()
    }

    pub(crate) fn cancel(&self) {
        self.alarm.clear();
    }
}