tokio/runtime/time/
handle.rs

1use crate::runtime::time::TimeSource;
2use std::fmt;
3
4/// Handle to time driver instance.
5pub(crate) struct Handle {
6    pub(super) time_source: TimeSource,
7    pub(super) inner: super::Inner,
8}
9
10impl Handle {
11    /// Returns the time source associated with this handle.
12    pub(crate) fn time_source(&self) -> &TimeSource {
13        &self.time_source
14    }
15
16    /// Checks whether the driver has been shutdown.
17    pub(super) fn is_shutdown(&self) -> bool {
18        self.inner.is_shutdown()
19    }
20
21    /// Track that the driver is being unparked
22    pub(crate) fn unpark(&self) {
23        #[cfg(feature = "test-util")]
24        self.inner
25            .did_wake
26            .store(true, std::sync::atomic::Ordering::SeqCst);
27    }
28}
29
30cfg_not_rt! {
31    impl Handle {
32        /// Tries to get a handle to the current timer.
33        ///
34        /// # Panics
35        ///
36        /// This function panics if there is no current timer set.
37        ///
38        /// It can be triggered when [`Builder::enable_time`] or
39        /// [`Builder::enable_all`] are not included in the builder.
40        ///
41        /// It can also panic whenever a timer is created outside of a
42        /// Tokio runtime. That is why `rt.block_on(sleep(...))` will panic,
43        /// since the function is executed outside of the runtime.
44        /// Whereas `rt.block_on(async {sleep(...).await})` doesn't panic.
45        /// And this is because wrapping the function on an async makes it lazy,
46        /// and so gets executed inside the runtime successfully without
47        /// panicking.
48        ///
49        /// [`Builder::enable_time`]: crate::runtime::Builder::enable_time
50        /// [`Builder::enable_all`]: crate::runtime::Builder::enable_all
51        #[track_caller]
52        pub(crate) fn current() -> Self {
53            panic!("{}", crate::util::error::CONTEXT_MISSING_ERROR)
54        }
55    }
56}
57
58impl fmt::Debug for Handle {
59    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
60        write!(f, "Handle")
61    }
62}