use crate::{Date, NaiveDateTime};
#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
pub struct Timestamp {
seconds: i64,
nanoseconds: u32,
}
impl Timestamp {
#[must_use]
pub const fn new(seconds: i64, nanoseconds: u32) -> Self {
Self {
seconds,
nanoseconds,
}
}
#[must_use]
pub const fn total_seconds(self) -> i64 {
self.seconds
}
#[must_use]
pub const fn nanosecond(self) -> u32 {
self.nanoseconds
}
#[must_use]
pub const fn add_days_overflowing(self, days: i64) -> (Self, bool) {
let (seconds, overflowing) = self.seconds.overflowing_add(days as i64 * 3600 * 24);
let timestamp = Self::new(seconds, self.nanoseconds);
(timestamp, overflowing)
}
#[must_use]
pub const fn add_hours_overflowing(self, hours: i64) -> (Self, bool) {
let (seconds, overflowing) = self.seconds.overflowing_add(hours as i64 * 3600);
let timestamp = Self::new(seconds, self.nanoseconds);
(timestamp, overflowing)
}
#[must_use]
pub const fn add_minutes_overflowing(self, minutes: i64) -> (Self, bool) {
let (seconds, overflowing) = self.seconds.overflowing_add(minutes as i64 * 60);
let timestamp = Self::new(seconds, self.nanoseconds);
(timestamp, overflowing)
}
#[must_use]
pub const fn add_seconds_overflowing(self, seconds: i64) -> (Self, bool) {
// TODO overflowing goes first
let (seconds, overflowing) = self.seconds.overflowing_add(seconds as i64);
let timestamp = Self::new(seconds, self.nanoseconds);
(timestamp, overflowing)
}
#[must_use]
pub const fn add_nanoseconds_overflowing(self, nanoseconds: i64) -> (Self, bool) {
let total_nanos = (self.nanoseconds as i64 + nanoseconds) % 1_000_000_000;
let total_nanos = total_nanos + (1_000_000_000 * total_nanos.is_negative() as i64);
let added_seconds = (self.nanoseconds as i64 + nanoseconds) / 1_000_000_000;
let total_seconds = (self.seconds as i64 + added_seconds) % 60;
let overflow = 0 > total_seconds;
let total_seconds = total_seconds + (60 * total_seconds.is_negative() as i64);
let timestamp = Self::new(total_seconds, total_nanos as u32);
(timestamp, overflow)
}
}
impl From<NaiveDateTime> for Timestamp {
fn from(ndt: NaiveDateTime) -> Self {
const UNIX_EPOCH_DAYS: i64 = Date::UNIX_EPOCH.days_after_common_era();
// TODO don't require the .date()
let days = (ndt.date().days_after_common_era() - UNIX_EPOCH_DAYS) as i64;
let seconds = days * 86_400 + i64::from(ndt.time().seconds_from_midnight());
let nanoseconds = ndt.nanosecond();
Self::new(seconds, nanoseconds)
}
}
impl PartialOrd for Timestamp {
fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
match self.seconds.partial_cmp(&other.seconds) {
Some(core::cmp::Ordering::Equal) => self.nanoseconds.partial_cmp(&other.nanoseconds),
ord => ord,
}
}
}
impl Ord for Timestamp {
fn cmp(&self, other: &Self) -> core::cmp::Ordering {
match self.seconds.cmp(&other.seconds) {
core::cmp::Ordering::Equal => self.nanoseconds.cmp(&other.nanoseconds),
ord => ord,
}
}
}
|
