oxihuman-core 0.1.2

Core data structures, algorithms, and asset management for OxiHuman
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
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
134
135
136
137
138
139
140
141
142
143
144
145

#![allow(dead_code)]

/// A timestamp in milliseconds.
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct Timestamp {
    pub ms: u64,
}

/// A deterministic time source (no real clock dependency).
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct TimeSource {
    current_ms: u64,
    start_ms: u64,
}

/// Creates a new time source starting at the given ms.
#[allow(dead_code)]
pub fn new_time_source(start_ms: u64) -> TimeSource {
    TimeSource {
        current_ms: start_ms,
        start_ms,
    }
}

/// Returns the current time in ms.
#[allow(dead_code)]
pub fn current_time_ms(ts: &TimeSource) -> u64 {
    ts.current_ms
}

/// Returns elapsed ms since a given timestamp.
#[allow(dead_code)]
pub fn elapsed_since(ts: &TimeSource, since: &Timestamp) -> u64 {
    ts.current_ms.saturating_sub(since.ms)
}

/// Returns the difference in ms between two timestamps.
#[allow(dead_code)]
pub fn time_diff_ms(a: &Timestamp, b: &Timestamp) -> i64 {
    (a.ms as i64) - (b.ms as i64)
}

/// Converts a timestamp to a simple string representation.
#[allow(dead_code)]
pub fn timestamp_to_string(t: &Timestamp) -> String {
    let secs = t.ms / 1000;
    let millis = t.ms % 1000;
    format!("{secs}.{millis:03}s")
}

/// Returns true if timestamp a is after timestamp b.
#[allow(dead_code)]
pub fn timestamp_is_after(a: &Timestamp, b: &Timestamp) -> bool {
    a.ms > b.ms
}

/// Adds milliseconds to a timestamp.
#[allow(dead_code)]
pub fn timestamp_add_ms(t: &Timestamp, ms: u64) -> Timestamp {
    Timestamp { ms: t.ms + ms }
}

/// Resets the time source to its start value.
#[allow(dead_code)]
pub fn time_source_reset(ts: &mut TimeSource) {
    ts.current_ms = ts.start_ms;
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_new_time_source() {
        let ts = new_time_source(1000);
        assert_eq!(current_time_ms(&ts), 1000);
    }

    #[test]
    fn test_elapsed_since() {
        let ts = new_time_source(5000);
        let stamp = Timestamp { ms: 3000 };
        assert_eq!(elapsed_since(&ts, &stamp), 2000);
    }

    #[test]
    fn test_time_diff_ms() {
        let a = Timestamp { ms: 5000 };
        let b = Timestamp { ms: 3000 };
        assert_eq!(time_diff_ms(&a, &b), 2000);
        assert_eq!(time_diff_ms(&b, &a), -2000);
    }

    #[test]
    fn test_timestamp_to_string() {
        let t = Timestamp { ms: 1500 };
        assert_eq!(timestamp_to_string(&t), "1.500s");
    }

    #[test]
    fn test_timestamp_is_after() {
        let a = Timestamp { ms: 200 };
        let b = Timestamp { ms: 100 };
        assert!(timestamp_is_after(&a, &b));
        assert!(!timestamp_is_after(&b, &a));
    }

    #[test]
    fn test_timestamp_add_ms() {
        let t = Timestamp { ms: 1000 };
        let t2 = timestamp_add_ms(&t, 500);
        assert_eq!(t2.ms, 1500);
    }

    #[test]
    fn test_time_source_reset() {
        let mut ts = new_time_source(100);
        ts.current_ms = 999;
        time_source_reset(&mut ts);
        assert_eq!(current_time_ms(&ts), 100);
    }

    #[test]
    fn test_elapsed_since_future() {
        let ts = new_time_source(100);
        let stamp = Timestamp { ms: 500 };
        assert_eq!(elapsed_since(&ts, &stamp), 0);
    }

    #[test]
    fn test_timestamp_equality() {
        let a = Timestamp { ms: 42 };
        let b = Timestamp { ms: 42 };
        assert_eq!(a, b);
    }

    #[test]
    fn test_timestamp_ordering() {
        let a = Timestamp { ms: 10 };
        let b = Timestamp { ms: 20 };
        assert!(a < b);
    }
}