tokio 1.52.1

An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications.
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

use super::{cancellation_queue, RegistrationQueue, Wheel};

/// Local context for the time driver, used when the runtime wants to
/// fire/cancel timers.
pub(crate) struct LocalContext {
    pub(crate) wheel: Wheel,
    pub(crate) registration_queue: RegistrationQueue,
    pub(crate) canc_tx: cancellation_queue::Sender,
    pub(crate) canc_rx: cancellation_queue::Receiver,
}

impl LocalContext {
    pub(crate) fn new() -> Self {
        let (canc_tx, canc_rx) = cancellation_queue::new();
        Self {
            wheel: Wheel::new(),
            registration_queue: RegistrationQueue::new(),
            canc_tx,
            canc_rx,
        }
    }
}

pub(crate) enum TempLocalContext<'a> {
    /// The runtime is running, we can access it.
    Running {
        registration_queue: &'a mut RegistrationQueue,
        elapsed: u64,
    },
    #[cfg(feature = "rt-multi-thread")]
    /// The runtime is shutting down, no timers can be registered.
    Shutdown,
}

impl<'a> TempLocalContext<'a> {
    pub(crate) fn new_running(cx: &'a mut LocalContext) -> Self {
        TempLocalContext::Running {
            registration_queue: &mut cx.registration_queue,
            elapsed: cx.wheel.elapsed(),
        }
    }

    #[cfg(feature = "rt-multi-thread")]
    pub(crate) fn new_shutdown() -> Self {
        TempLocalContext::Shutdown
    }
}