#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct Duration(u64);
impl Duration {
pub const ZERO: Self = Self(0);
pub const MAX: Self = Self(u64::MAX);
#[must_use]
pub const fn from_micros(micros: u64) -> Self {
Self(micros)
}
#[must_use]
pub const fn from_millis(millis: u64) -> Self {
Self(millis.saturating_mul(1_000))
}
#[must_use]
pub const fn from_secs(secs: u64) -> Self {
Self(secs.saturating_mul(1_000_000))
}
#[must_use]
pub const fn as_micros(self) -> u64 {
self.0
}
#[must_use]
pub const fn as_millis(self) -> u64 {
self.0.wrapping_div(1_000)
}
#[must_use]
pub const fn as_secs(self) -> u64 {
self.0.wrapping_div(1_000_000)
}
#[must_use]
pub const fn saturating_add(self, other: Self) -> Self {
Self(self.0.saturating_add(other.0))
}
#[must_use]
pub const fn saturating_sub(self, other: Self) -> Self {
Self(self.0.saturating_sub(other.0))
}
#[must_use]
pub const fn saturating_mul(self, factor: u64) -> Self {
Self(self.0.saturating_mul(factor))
}
#[must_use]
pub const fn mul_ratio(self, numerator: u64, denominator: u64) -> Self {
let (Some(whole), Some(rest)) = (
self.0.checked_div(denominator),
self.0.checked_rem(denominator),
) else {
return Self::MAX;
};
let Some(fraction) = rest.saturating_mul(numerator).checked_div(denominator) else {
return Self::MAX;
};
Self(whole.saturating_mul(numerator).saturating_add(fraction))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct Instant(u64);
impl Instant {
pub const ZERO: Self = Self(0);
pub const MAX: Self = Self(u64::MAX);
#[must_use]
pub const fn from_micros(micros: u64) -> Self {
Self(micros)
}
#[must_use]
pub const fn as_micros(self) -> u64 {
self.0
}
#[must_use]
pub const fn as_millis(self) -> u64 {
self.0 / 1000
}
#[must_use]
pub const fn saturating_add(self, d: Duration) -> Self {
Self(self.0.saturating_add(d.0))
}
#[must_use]
pub const fn saturating_sub(self, d: Duration) -> Self {
Self(self.0.saturating_sub(d.0))
}
#[must_use]
pub const fn saturating_duration_since(self, earlier: Self) -> Duration {
Duration(self.0.saturating_sub(earlier.0))
}
#[must_use]
pub const fn is_elapsed_at(self, now: Self) -> bool {
now.0 >= self.0
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn unit_conversions() {
assert_eq!(Duration::from_millis(1).as_micros(), 1_000);
assert_eq!(Duration::from_secs(1).as_millis(), 1_000);
assert_eq!(Duration::from_micros(1_999).as_millis(), 1);
}
#[test]
fn arithmetic_saturates_rather_than_wrapping() {
assert_eq!(
Duration::MAX.saturating_add(Duration::from_secs(1)),
Duration::MAX
);
assert_eq!(
Duration::ZERO.saturating_sub(Duration::from_secs(1)),
Duration::ZERO
);
assert_eq!(Duration::MAX.saturating_mul(2), Duration::MAX);
assert_eq!(
Instant::MAX.saturating_add(Duration::from_secs(1)),
Instant::MAX
);
assert_eq!(
Instant::ZERO.saturating_sub(Duration::from_secs(1)),
Instant::ZERO
);
assert_eq!(Duration::from_secs(u64::MAX), Duration::MAX);
}
#[test]
fn mul_ratio_is_mrps_arithmetic() {
let base = Duration::from_millis(300);
assert_eq!(base.mul_ratio(16, 10).as_millis(), 480);
assert_eq!(base.mul_ratio(11, 10).as_millis(), 330);
assert_eq!(base.mul_ratio(1, 4).as_millis(), 75);
assert_eq!(Duration::from_micros(7).mul_ratio(16, 10).as_micros(), 11);
assert_eq!(base.mul_ratio(1, 0), Duration::MAX);
}
#[test]
fn instants_order_and_subtract() {
let a = Instant::from_micros(100);
let b = Instant::from_micros(250);
assert!(a < b);
assert_eq!(b.saturating_duration_since(a), Duration::from_micros(150));
assert_eq!(a.saturating_duration_since(b), Duration::ZERO);
assert!(a.is_elapsed_at(b));
assert!(!b.is_elapsed_at(a));
assert!(
a.is_elapsed_at(a),
"a deadline is reached at its own instant"
);
}
}