cnsprcy 0.3.2

WIP
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
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

use std::time::Duration;

use tokio::time::{
	Instant,
	sleep_until
};
use tracing::{
	debug_span,
	Span,
	Instrument
};

pub struct Sleeper {
	span: Span,
	pushed: Duration,
	until: Option<Instant>
}

impl Sleeper {

	pub fn start() -> Self {
		Self {
			span: debug_span!("sleep"),
			pushed: Duration::ZERO,
			until: None
		}
	}

	pub fn push(&mut self, amount: Duration) {
		match Instant::now().checked_add(amount) {
			Some(until) => {
				self.pushed = amount;
				self.until = Some(until);
				debug!(@self, "next tick in {amount:?}");
			},
			None => {
				self.pushed = Duration::ZERO;
				self.until = None;
				warn!(@self, "Instant overflowed, not pushed!");
			}
		}
	}

	pub async fn sleep(&mut self) -> Option<()> {
		sleep_until(self.until?).in_current_span().await;
		self.until.take();
		debug!(@self, "slept for {:?}", self.pushed);
		self.pushed = Duration::ZERO;
		Some(())
	}
}

#[test_log::test(tokio::test(start_paused = true))]
async fn sleep() {
	use futures::FutureExt;
	const PUSH: Duration = Duration::from_secs(3);

	let mut sleeper = Sleeper::start();

	let not_pushed = sleeper.sleep().now_or_never();
	assert_eq!(
		not_pushed,
		Some(None),
		"not pushed, should be ready immediately"
	);

	let before = Instant::now();
	sleeper.push(PUSH);
	sleeper.sleep().await.unwrap();
	let elapsed = Instant::now() - before;
	assert!(elapsed >= PUSH, "should sleep for at least {PUSH:?}");

	let cleared = sleeper.sleep().now_or_never();
	assert_eq!(
		cleared,
		Some(None),
		"cleared, should be ready immediately"
	);

	// Overflow the Instant
	sleeper.push(Duration::MAX);
	let cleared = sleeper.sleep().now_or_never();
	assert_eq!(
		cleared,
		Some(None),
		"cleared because of overflow, should be ready immediately"
	);
}