ratelock 0.1.0

Zero-dependency, zero-allocation, lock-free token bucket rate limiter for Rust (std + no_std).
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

use std::sync::atomic::{AtomicU64, Ordering};

use ratelock::Clock;

pub struct MockClock {
    now: AtomicU64,
}

impl MockClock {
    pub const fn new(start_ns: u64) -> Self {
        Self {
            now: AtomicU64::new(start_ns),
        }
    }

    pub fn advance_ns(&self, ns: u64) {
        self.now.fetch_add(ns, Ordering::SeqCst);
    }

    pub fn advance_ms(&self, ms: u64) {
        self.advance_ns(ms.saturating_mul(1_000_000));
    }

    pub fn advance_sec(&self, sec: u64) {
        self.advance_ns(sec.saturating_mul(1_000_000_000));
    }
}

impl Clock for MockClock {
    fn now_ns(&self) -> u64 {
        self.now.load(Ordering::SeqCst)
    }
}

impl Clock for &MockClock {
    fn now_ns(&self) -> u64 {
        self.now.load(Ordering::SeqCst)
    }
}

#[test]
fn mock_clock_advances_correctly() {
    let clock = MockClock::new(0);
    assert_eq!(clock.now_ns(), 0);

    clock.advance_ms(500);
    assert_eq!(clock.now_ns(), 500_000_000);

    clock.advance_sec(1);
    assert_eq!(clock.now_ns(), 1_500_000_000);
}