eryon_core/time/

timestamp.rs

/*
    Appellation: timestamp <module>
    Contrib: @FL03
*/
/// a type alias for timestamps created with the standard library
pub type Ts = u128;

#[derive(Clone, Copy, Default, Eq, Hash, PartialEq, Ord, PartialOrd)]
#[cfg_attr(
    feature = "serde",
    derive(serde_derive::Deserialize, serde_derive::Serialize)
)]
pub struct Timestamp<T = Ts>(pub T);

impl<T> Timestamp<T> {
    pub fn from_value(index: T) -> Self {
        Timestamp(index)
    }
    /// returns a pointer to the inner value
    pub const fn as_ptr(&self) -> *const T {
        core::ptr::from_ref(&self.0)
    }
    /// returns a mutable pointer to the inner value
    pub fn as_mut_ptr(&mut self) -> *mut T {
        core::ptr::from_mut(&mut self.0)
    }
    /// consumes the index returning the inner value
    #[inline]
    pub fn into_inner(self) -> T {
        self.0
    }
    /// returns an immutable reference to the inner value
    pub const fn get(&self) -> &T {
        &self.0
    }
    /// returns a mutable reference to the inner value
    pub fn get_mut(&mut self) -> &mut T {
        &mut self.0
    }
    /// apply a function to the inner value and returns a new Timestamp wrapping the result
    pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Timestamp<U> {
        Timestamp(f(self.0))
    }
    /// replaces the inner value with the given one and returns the old value
    pub const fn replace(&mut self, index: T) -> T {
        core::mem::replace(&mut self.0, index)
    }
    /// set the index to the given value
    pub fn set(&mut self, index: T) {
        self.0 = index;
    }
    /// swap the values of two indices
    pub const fn swap(&mut self, other: &mut Self) {
        core::mem::swap(&mut self.0, &mut other.0)
    }
}

impl<T> From<T> for Timestamp<T> {
    fn from(index: T) -> Self {
        Timestamp(index)
    }
}

impl<T> PartialEq<T> for Timestamp<T>
where
    T: PartialEq,
{
    fn eq(&self, other: &T) -> bool {
        &self.0 == other
    }
}

impl Timestamp<u64> {
    #[cfg(feature = "std")]
    pub fn now_in_secs() -> Self {
        Self(
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap_or_default()
                .as_secs(),
        )
    }
    /// convert the timestamp (in seconds) to milliseconds
    pub fn as_millis(&self) -> u128 {
        self.0 as u128 * 1000
    }
}

impl Timestamp<u128> {
    #[cfg(feature = "std")]
    pub fn now() -> Self {
        Self(
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap_or_default()
                .as_millis(),
        )
    }
    #[cfg(feature = "std")]
    pub fn now_in_millis() -> Self {
        Self(super::utils::std_time())
    }
}

impl<T> core::convert::AsRef<T> for Timestamp<T> {
    fn as_ref(&self) -> &T {
        &self.0
    }
}

impl<T> core::convert::AsMut<T> for Timestamp<T> {
    fn as_mut(&mut self) -> &mut T {
        &mut self.0
    }
}

impl<T> core::borrow::Borrow<T> for Timestamp<T> {
    fn borrow(&self) -> &T {
        &self.0
    }
}

impl<T> core::borrow::BorrowMut<T> for Timestamp<T> {
    fn borrow_mut(&mut self) -> &mut T {
        &mut self.0
    }
}

impl<T> core::ops::Deref for Timestamp<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T> core::ops::DerefMut for Timestamp<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<T> core::ops::Neg for Timestamp<T>
where
    T: core::ops::Neg,
{
    type Output = Timestamp<<T as core::ops::Neg>::Output>;

    fn neg(self) -> Self::Output {
        Timestamp(-self.0)
    }
}

impl<T> core::ops::Not for Timestamp<T>
where
    T: core::ops::Not,
{
    type Output = Timestamp<<T as core::ops::Not>::Output>;

    fn not(self) -> Self::Output {
        Timestamp(!self.0)
    }
}

impl<T> num::One for Timestamp<T>
where
    T: num::One,
{
    fn one() -> Self {
        Timestamp(T::one())
    }
}

impl<T> num::Zero for Timestamp<T>
where
    T: num::Zero,
{
    fn zero() -> Self {
        Timestamp(T::zero())
    }

    fn is_zero(&self) -> bool {
        self.0.is_zero()
    }
}

impl<T> num::Num for Timestamp<T>
where
    T: num::Num,
{
    type FromStrRadixErr = T::FromStrRadixErr;

    fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
        T::from_str_radix(str, radix).map(Timestamp)
    }
}

macro_rules! impl_fmt {
    ($($trait:ident),* $(,)?) => {
        $(impl<T: core::fmt::$trait> core::fmt::$trait for Timestamp<T> {
            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
                core::fmt::$trait::fmt(&self.0, f)
            }
        })*
    };
}

macro_rules! impl_bin_op {
    (@impl $trait:ident::$method:ident) => {
        impl<A, B, C> core::ops::$trait<Timestamp<B>> for Timestamp<A> where A: core::ops::$trait<B, Output = C>{
            type Output = Timestamp<C>;

            fn $method(self, rhs: Timestamp<B>) -> Self::Output {
                Timestamp(core::ops::$trait::$method(self.0, rhs.0))
            }
        }
    };

    ($($trait:ident::$method:ident),* $(,)?) => {
        $(impl_bin_op!(@impl $trait::$method);)*
    };
}

macro_rules! impl_assign_op {
    (@impl $trait:ident::$method:ident) => {
        impl<A, B> core::ops::$trait<B> for Timestamp<A> where A: core::ops::$trait<B> {
            fn $method(&mut self, rhs: B) {
                core::ops::$trait::$method(&mut self.0, rhs)
            }
        }
    };

    ($($trait:ident::$method:ident),* $(,)?) => {
        $(impl_assign_op!(@impl $trait::$method);)*
    };
}

impl_assign_op! {
    AddAssign::add_assign,
    SubAssign::sub_assign,
    MulAssign::mul_assign,
    DivAssign::div_assign,
    RemAssign::rem_assign,
    BitAndAssign::bitand_assign,
    BitOrAssign::bitor_assign,
    BitXorAssign::bitxor_assign,
    ShlAssign::shl_assign,
    ShrAssign::shr_assign,
}

impl_bin_op! {
    Add::add,
    Sub::sub,
    Mul::mul,
    Div::div,
    Rem::rem,
    BitAnd::bitand,
    BitOr::bitor,
    BitXor::bitxor,
    Shl::shl,
    Shr::shr,
}

impl_fmt! {
    Binary,
    Debug,
    Display,
    LowerExp,
    LowerHex,
    Octal,
    Pointer,
    UpperExp,
    UpperHex,
}