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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use core::{
  future::Future,
  pin::Pin,
  task::{Context, Poll},
  time::Duration,
};
use std::time::Instant;
use wasm::Delay;

use crate::time::{AsyncLocalSleep, AsyncLocalSleepExt};

pin_project_lite::pin_project! {
  /// The [`AsyncSleep`] implementation for wasm-bindgen based runtime.
  #[cfg_attr(docsrs, doc(cfg(all(feature = "std", feature = "wasm"))))]
  pub struct WasmSleep {
    #[pin]
    pub(crate) sleep: Delay,
    pub(crate) ddl: Instant,
    pub(crate) duration: Duration,
  }
}

impl Future for WasmSleep {
  type Output = Instant;

  fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
    let ddl = self.ddl;
    self.project().sleep.poll(cx).map(|_| ddl)
  }
}

impl AsyncLocalSleep for WasmSleep {
  fn reset(self: Pin<&mut Self>, deadline: Instant) {
    let mut this = self.project();
    let ddl = deadline - Instant::now();
    this.sleep.reset(ddl);
    *this.ddl = deadline;
  }
}

impl AsyncLocalSleepExt for WasmSleep {
  fn sleep_local(after: Duration) -> Self
  where
    Self: Sized,
  {
    Self {
      ddl: Instant::now() + after,
      sleep: Delay::new(after),
      duration: after,
    }
  }

  fn sleep_local_until(deadline: Instant) -> Self
  where
    Self: Sized,
  {
    let duration = deadline - Instant::now();
    Self {
      sleep: Delay::new(duration),
      ddl: deadline,
      duration,
    }
  }
}

#[cfg(test)]
mod tests {
  use super::WasmSleep;
  use crate::time::{AsyncSleep, AsyncSleepExt};
  use core::pin::Pin;
  use std::time::{Duration, Instant};

  const ORIGINAL: Duration = Duration::from_secs(1);
  const RESET: Duration = Duration::from_secs(2);
  const BOUND: Duration = Duration::from_millis(10);

  #[test]
  fn test_object_safe() {
    let _a: Box<dyn AsyncSleep> = Box::new(WasmSleep::sleep(ORIGINAL));
  }

  #[test]
  fn test_wasm_sleep() {
    futures::executor::block_on(async {
      let start = Instant::now();
      let sleep = WasmSleep::sleep(ORIGINAL);
      let ins = sleep.await;
      assert!(ins >= start + ORIGINAL);
      let elapsed = start.elapsed();
      assert!(elapsed >= ORIGINAL && elapsed < ORIGINAL + BOUND);
    });
  }

  #[test]
  fn test_wasm_sleep_until() {
    futures::executor::block_on(async {
      let start = Instant::now();
      let sleep = WasmSleep::sleep_until(start + ORIGINAL);
      let ins = sleep.await;
      assert!(ins >= start + ORIGINAL);
      let elapsed = start.elapsed();
      assert!(elapsed >= ORIGINAL && elapsed < ORIGINAL + BOUND);
    });
  }

  #[test]
  fn test_wasm_sleep_reset() {
    futures::executor::block_on(async {
      let start = Instant::now();
      let mut sleep = WasmSleep::sleep(ORIGINAL);
      let pin = Pin::new(&mut sleep);
      pin.reset(Instant::now() + RESET);
      let ins = sleep.await;
      assert!(ins >= start + RESET);
      let elapsed = start.elapsed();
      assert!(elapsed >= RESET && elapsed < RESET + BOUND);
    });
  }

  #[test]
  fn test_wasm_sleep_reset2() {
    futures::executor::block_on(async {
      let start = Instant::now();
      let mut sleep = WasmSleep::sleep_until(start + ORIGINAL);
      let pin = Pin::new(&mut sleep);
      pin.reset(Instant::now() + RESET);
      let ins = sleep.await;
      assert!(ins >= start + RESET);
      let elapsed = start.elapsed();
      assert!(elapsed >= RESET && elapsed < RESET + BOUND);
    });
  }
}