use std::{fmt, ops::Div};
use speedy::{Readable, Writable};
use serde::{Deserialize, Serialize};
#[derive(
PartialEq, Eq, Hash, PartialOrd, Ord, Readable, Writable, Serialize, Deserialize, Copy, Clone,
)]
pub struct Duration {
seconds: i32,
fraction: u32, }
impl Duration {
pub const ZERO: Self = Self {
seconds: 0,
fraction: 0,
};
pub const INFINITE: Self = Self {
seconds: 0x7FFFFFFF,
fraction: 0xFFFFFFFF,
};
#[deprecated(since = "0.8.7", note = "Renamed to Duration::ZERO")]
pub const DURATION_ZERO: Self = Self::ZERO;
#[deprecated(since = "0.8.7", note = "Renamed to Duration::INFINITE")]
pub const DURATION_INFINITE: Self = Self::INFINITE;
pub const fn from_secs(secs: i32) -> Self {
Self {
seconds: secs, fraction: 0,
}
}
pub fn from_frac_seconds(secs: f64) -> Self {
Self {
seconds: secs.trunc() as i32,
fraction: (secs.fract().abs() * 32.0_f64.exp2()) as u32,
}
}
pub const fn from_millis(millis: i64) -> Self {
let fraction = (((millis % 1000) << 32) / 1000) as u32;
Self {
seconds: (millis / 1000) as i32,
fraction,
}
}
pub const fn from_nanos(nanos: i64) -> Self {
let fraction = (((nanos % 1_000_000_000) << 32) / 1_000_000_000) as u32;
Self {
seconds: (nanos / 1_000_000_000) as i32,
fraction,
}
}
pub(crate) fn to_ticks(self) -> i64 {
(i64::from(self.seconds) << 32) + i64::from(self.fraction)
}
pub(crate) fn from_ticks(ticks: i64) -> Self {
Self {
seconds: (ticks >> 32) as i32,
fraction: ticks as u32,
}
}
pub fn to_nanoseconds(&self) -> i64 {
((i128::from(self.to_ticks()) * 1_000_000_000) >> 32) as i64
}
pub fn from_std(duration: std::time::Duration) -> Self {
Self::from(duration)
}
pub fn to_std(&self) -> std::time::Duration {
std::time::Duration::from(*self)
}
}
impl From<Duration> for chrono::Duration {
fn from(d: Duration) -> Self {
Self::nanoseconds(d.to_nanoseconds())
}
}
impl From<std::time::Duration> for Duration {
fn from(duration: std::time::Duration) -> Self {
Self {
seconds: duration.as_secs() as i32,
fraction: ((u64::from(duration.subsec_nanos()) << 32) / 1_000_000_000) as u32,
}
}
}
impl From<Duration> for std::time::Duration {
fn from(d: Duration) -> Self {
Self::from_nanos(
u64::try_from(d.to_nanoseconds()).unwrap_or(0), )
}
}
impl Div<i64> for Duration {
type Output = Self;
fn div(self, rhs: i64) -> Self {
Self::from_ticks(self.to_ticks() / rhs)
}
}
impl std::ops::Add for Duration {
type Output = Self;
fn add(self, other: Self) -> Self {
Self::from_ticks(self.to_ticks() + other.to_ticks())
}
}
impl std::ops::Mul<Duration> for f64 {
type Output = Duration;
fn mul(self, rhs: Duration) -> Duration {
Duration::from_ticks((self * (rhs.to_ticks() as Self)) as i64)
}
}
impl fmt::Debug for Duration {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if *self == Self::INFINITE {
write!(f, "infinite")
} else {
write!(f, "{}", self.seconds)?;
if self.fraction > 0 {
let frac = format!("{:09}", (1_000_000_000 * (self.fraction as u64)) >> 32);
write!(f, ".{}", frac.trim_end_matches('0'))?;
}
write!(f, " sec")
}
}
}
#[cfg(test)]
mod tests {
use super::*;
serialization_test!( type = Duration,
{
duration_zero,
Duration::ZERO,
le = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
be = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
},
{
duration_infinite,
Duration::INFINITE,
le = [0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF],
be = [0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
},
{
duration_current_empty_fraction,
Duration { seconds: 1_537_045_491, fraction: 0 },
le = [0xF3, 0x73, 0x9D, 0x5B, 0x00, 0x00, 0x00, 0x00],
be = [0x5B, 0x9D, 0x73, 0xF3, 0x00, 0x00, 0x00, 0x00]
},
{
duration_from_wireshark,
Duration { seconds: 1_519_152_760, fraction: 1_328_210_046 },
le = [0x78, 0x6E, 0x8C, 0x5A, 0x7E, 0xE0, 0x2A, 0x4F],
be = [0x5A, 0x8C, 0x6E, 0x78, 0x4F, 0x2A, 0xE0, 0x7E]
});
const NANOS_PER_SEC: u64 = 1_000_000_000;
#[test]
fn convert_from_duration() {
let duration = std::time::Duration::from_nanos(1_519_152_761 * NANOS_PER_SEC + 328_210_046);
let duration: Duration = duration.into();
assert_eq!(
duration,
Duration {
seconds: 1_519_152_761,
fraction: 1_409_651_413,
}
);
}
#[test]
fn convert_to_duration() {
let duration = Duration {
seconds: 1_519_152_760,
fraction: 1_328_210_046,
};
let duration: std::time::Duration = duration.into();
assert_eq!(
duration,
std::time::Duration::from_nanos(1_519_152_760 * NANOS_PER_SEC + 309_247_999)
);
}
fn fmt_check(d: Duration, s: &str) {
assert_eq!(format!("{:?}", d), s);
}
#[test]
fn duration_format() {
fmt_check(Duration::from_frac_seconds(0.0), "0 sec");
fmt_check(Duration::from_frac_seconds(0.5), "0.5 sec");
fmt_check(Duration::from_frac_seconds(1.5), "1.5 sec");
fmt_check(Duration::from_frac_seconds(20.0), "20 sec");
fmt_check(Duration::from_frac_seconds(2.25), "2.25 sec");
fmt_check(Duration::from_frac_seconds(10.0 / 3.0), "3.333333333 sec");
}
}