madsim 0.2.34

Deterministic Simulator for distributed systems.
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

use super::*;
use std::{fmt, pin::Pin, task::Poll};

/// Waits until `duration` has elapsed.
pub fn sleep(duration: Duration) -> Sleep {
    let handle = TimeHandle::current();
    handle.sleep(duration)
}

/// Waits until `deadline` is reached.
pub fn sleep_until(deadline: Instant) -> Sleep {
    let handle = TimeHandle::current();
    handle.sleep_until(deadline)
}

/// Future returned by [`sleep`] and [`sleep_until`].
///
/// [`sleep`]: sleep()
#[must_use = "futures do nothing unless you `.await` or poll them"]
pub struct Sleep {
    pub(super) handle: TimeHandle,
    pub(super) deadline: Instant,
}

impl Sleep {
    /// Returns the instant at which the future will complete.
    pub fn deadline(&self) -> Instant {
        self.deadline
    }

    /// Returns `true` if `Sleep` has elapsed.
    ///
    /// A `Sleep` instance is elapsed when the requested duration has elapsed.
    pub fn is_elapsed(&self) -> bool {
        self.handle.clock.now_instant() >= self.deadline
    }

    /// Resets the `Sleep` instance to a new deadline.
    pub fn reset(mut self: Pin<&mut Self>, deadline: Instant) {
        self.deadline = deadline;
    }
}

impl Future for Sleep {
    type Output = ();

    fn poll(self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<Self::Output> {
        if self.is_elapsed() {
            return Poll::Ready(());
        }
        let waker = cx.waker().clone();
        self.handle.add_timer_at(self.deadline, || waker.wake());
        Poll::Pending
    }
}

impl fmt::Debug for Sleep {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Sleep")
            .field("deadline", &self.deadline)
            .finish()
    }
}