timer-deque-rs 0.8.0

#[cfg(
     any(
            target_os = "freebsd",
            target_os = "dragonfly",
            target_os = "netbsd",
            target_os = "openbsd",
            target_os = "macos",
        )
    )
]
pub mod bsd;

#[cfg(target_os = "linux")]
pub mod linux;

use std::{fmt, io};
pub use std::os::fd::{AsFd, AsRawFd, BorrowedFd, RawFd};

pub use nix::libc::{self, ECANCELED, EWOULDBLOCK};

// --- event watch ---
#[cfg(target_os = "linux")]
pub use linux::timer_poll::TimerEventWatch;


#[cfg(
    any(
        target_os = "freebsd",
        target_os = "dragonfly",
        target_os = "netbsd",
        target_os = "openbsd",
        target_os = "macos",
    )
)]
pub use bsd::TimerEventWatch;


// --- timer id ---
#[cfg(target_os = "linux")]
pub use linux::timer_fd_linux::TimerFdInternal;

use crate::{AbsoluteTime, RelativeTime, TimerFd, TimerReadRes, timer_portable::{TimerExpMode, TimerId, timer::ModeTimeType}};

#[cfg(
    all(
        any(
            target_os = "freebsd",
            target_os = "dragonfly",
            target_os = "netbsd",
            target_os = "openbsd",
            target_os = "macos",
        ),
        feature = "bsd_use_timerfd"
    )
)]
pub use bsd::timer_fd_bsd::TimerFdInternal;

#[cfg(
    all(
        any(
            target_os = "freebsd",
            target_os = "dragonfly",
            target_os = "netbsd",
            target_os = "openbsd",
            target_os = "macos",
        ),
        not(feature = "bsd_use_timerfd")
    )
)]
pub use bsd::timer_kqueue_fd_bsd::TimerFdInternal;


use bitflags::bitflags;

/// A timer type
#[allow(non_camel_case_types)]
#[repr(i32)]
#[derive(Debug)]
pub enum TimerType
{
    /// A settable system-wide real-time clock.
    CLOCK_REALTIME = libc::CLOCK_REALTIME,

    /// A nonsettable monotonically increasing clock that measures  time
    /// from some unspecified point in the past that does not change af‐
    /// ter system startup.

    CLOCK_MONOTONIC = libc::CLOCK_MONOTONIC,

    
    /// Like CLOCK_MONOTONIC, this is a monotonically increasing  clock.
    /// However,  whereas the CLOCK_MONOTONIC clock does not measure the
    /// time while a system is suspended, the CLOCK_BOOTTIME clock  does
    /// include  the time during which the system is suspended.  This is
    /// useful  for  applications  that  need   to   be   suspend-aware.
    /// CLOCK_REALTIME is not suitable for such applications, since that
    /// clock is affected by discontinuous changes to the system clock.
    #[cfg(target_os = "linux")]
    CLOCK_BOOTTIME = libc::CLOCK_BOOTTIME,

    /// This clock is like CLOCK_REALTIME, but will wake the  system  if
    /// it  is suspended.  The caller must have the CAP_WAKE_ALARM capa‐
    /// bility in order to set a timer against this clock.
    #[cfg(target_os = "linux")]
    CLOCK_REALTIME_ALARM = libc::CLOCK_REALTIME_ALARM,

    /// This clock is like CLOCK_BOOTTIME, but will wake the  system  if
    /// it  is suspended.  The caller must have the CAP_WAKE_ALARM capa‐
    /// bility in order to set a timer against this clock.
    #[cfg(target_os = "linux")]
    CLOCK_BOOTTIME_ALARM = libc::CLOCK_BOOTTIME_ALARM,
}

impl From<TimerType> for libc::clockid_t 
{
    fn from(value: TimerType) -> Self 
    {
        return value as libc::clockid_t;
    }
}


bitflags! {     
    /// Flags controling the type of the timer type.  
    #[derive(Default, Debug, Clone, Copy, PartialEq, Eq)] 
    pub struct TimerFlags: i32  
    {     
        /// Set the O_NONBLOCK file status flag on the open file  de‐
        /// scription  (see  open(2)) referred to by the new file de‐
        /// scriptor.  Using this flag saves extra calls to  fcntl(2)
        /// to achieve the same result.
        const TFD_NONBLOCK = libc::TFD_NONBLOCK;

        /// Set  the  close-on-exec (FD_CLOEXEC) flag on the new file
        /// descriptor.  See the description of the O_CLOEXEC flag in
        /// open(2) for reasons why this may be useful.
        const TFD_CLOEXEC = libc::TFD_CLOEXEC;
    }
}


bitflags! {     
    /// A bit mask that can include the values.
    #[derive(Default, Debug, Eq, PartialEq, Clone, Copy)] 
    pub struct TimerSetTimeFlags: i32  
    {     
        /// > Interpret  new_value.it_value as an absolute value on the timer's
        /// > clock.  The timer will expire when the value of the timer's clock
        /// > reaches the value specified in new_value.it_value.
        const TFD_TIMER_ABSTIME = libc::TFD_TIMER_ABSTIME;

        /// > If this flag is specified along with  TFD_TIMER_ABSTIME  and  the
        /// > clock  for  this timer is CLOCK_REALTIME or CLOCK_REALTIME_ALARM,
        /// > then mark this timer as cancelable if the real-time clock  under‐
        /// > goes  a  discontinuous change (settimeofday(2), clock_settime(2),
        /// > or similar).  When  such  changes  occur,  a  current  or  future
        /// > read(2)  from  the file descriptor will fail with the error 
        /// > ECANCELED.
        const TFD_TIMER_CANCEL_ON_SET = libc::TFD_TIMER_CANCEL_ON_SET;
    }
}

// ------- TIMER ID -----
impl From<RawFd> for TimerId
{
    fn from(value: RawFd) -> Self 
    {
        return Self(value as usize);
    }
}

impl From<u64> for TimerId
{
    fn from(value: u64) -> Self 
    {
        return Self(value as usize);
    }
}

/*
impl From<&TimerFd> for TimerId
{
    fn from(value: &TimerFd) -> Self 
    {
        return Self(value.as_raw_handle() as usize);
    }
}*/


impl PartialEq<RawFd> for TimerId
{
    fn eq(&self, other: &RawFd) -> bool 
    {
        return self.0 == *other as usize;
    }
}

// ----- / TIMER ID / ---

pub trait UnixFd: AsFd + AsRawFd + PartialEq<RawFd> {}

// ---- TimerFd ------

/// Implementation for the TimrFD.
impl UnixFd for TimerFd {}

impl PartialEq<RawFd> for TimerFd
{
    fn eq(&self, other: &RawFd) -> bool 
    {
        return self.as_raw_fd() == *other;
    }
}

impl AsFd for TimerFd
{
    fn as_fd(&self) -> BorrowedFd<'_> 
    {
        return self.get_timer().as_fd();
    }
}

impl AsRawFd for TimerFd
{
    fn as_raw_fd(&self) -> RawFd 
    {
        return self.get_timer().as_raw_fd();
    }
}

// -----------------------

pub use nix::libc::{itimerspec, timespec};

/// Converts from [itimerspec] into [TimerExpMode] of the `TIMERTYPE`.
impl<TIMERTYPE: ModeTimeType> From<itimerspec> for TimerExpMode<TIMERTYPE>
{
    fn from(value: itimerspec) -> Self 
    {
        if value.it_interval.tv_sec == 0 && value.it_interval.tv_nsec == 0 &&
            value.it_value.tv_sec == 0 && value.it_value.tv_nsec == 0
        {
            // unset
            return Self::None;
        }
        else if value.it_interval.tv_sec == 0 && value.it_interval.tv_nsec == 0
        {
            // one shot
            return 
                Self::OneShot
                { 
                    timeout: TIMERTYPE::from(value.it_value) 
                };
        }
        else if value.it_interval.tv_sec == value.it_value.tv_sec &&
            value.it_interval.tv_nsec == value.it_value.tv_nsec
        {
            // interval
            return 
                Self::Interval
                { 
                    interv_tm: TIMERTYPE::from(value.it_interval) 
                };
        }
        else
        {
            // delayed interval
            return 
                Self::IntervalDelayed 
                { 
                    delay_tm: TIMERTYPE::from(value.it_value),
                    interv_tm: TIMERTYPE::from(value.it_interval) 
                };
        }
    }
}

impl From<timespec> for RelativeTime
{
    fn from(time_spec: timespec) -> Self 
    {
        return   
            Self::new_time(time_spec.tv_sec, time_spec.tv_nsec);
    }
}


impl From<timespec> for AbsoluteTime
{
    fn from(time_spec: timespec) -> Self 
    {
        return 
            unsafe 
            { 
                Self::new_time_unchecked(time_spec.tv_sec, time_spec.tv_nsec) 
            };
    }
}

impl<T: Sized + fmt::Debug + fmt::Display + Clone + Eq + PartialEq> From<io::Error> for TimerReadRes<T>
{
    fn from(value: io::Error) -> Self 
    {
        if let Some(errn) = value.raw_os_error()
        {
            if errn == ECANCELED
            {
                return Self::Cancelled;
            }
            else if errn == EWOULDBLOCK
            {
                return Self::WouldBlock;
            }
        }

        return Self::Cancelled;
    }
}

impl<TIMERTYPE: ModeTimeType> From<TimerExpMode<TIMERTYPE>> for itimerspec
{
    fn from(value: TimerExpMode<TIMERTYPE>) -> Self 
    {
        return (&value).into();
    }
}

/// Converts from the reference to [TimerExpMode] of the `TIMERTYPE` into the 
/// [itimerspec].
impl<TIMERTYPE: ModeTimeType> From<&TimerExpMode<TIMERTYPE>> for itimerspec
{
    fn from(value: &TimerExpMode<TIMERTYPE>) -> Self 
    {
        match value
        {
            TimerExpMode::None => 
                return 
                    itimerspec 
                    {
                        it_interval: timespec 
                        {
                            tv_sec: 0,
                            tv_nsec: 0,
                        },
                        it_value: timespec
                        {
                            tv_sec: 0,
                            tv_nsec: 0,
                        },
                    },
            TimerExpMode::OneShot{ timeout} =>
                return 
                    itimerspec 
                    {
                        it_interval: timespec 
                        {
                            tv_sec: 0,
                            tv_nsec: 0,
                        },
                        it_value: timespec
                        {
                            tv_sec: timeout.get_sec(),
                            tv_nsec: timeout.get_nsec(),
                        },
                    },
            TimerExpMode::IntervalDelayed{ delay_tm, interv_tm } => 
                return 
                    itimerspec 
                    {
                        it_interval: timespec 
                        {
                            tv_sec: interv_tm.get_sec(),
                            tv_nsec: interv_tm.get_nsec(),
                        },
                        it_value: timespec
                        {
                            tv_sec: delay_tm.get_sec(),
                            tv_nsec: delay_tm.get_nsec(),
                        },
                    },
            TimerExpMode::Interval{ interv_tm } => 
                return 
                    itimerspec 
                    {
                        it_interval: timespec 
                        {
                            tv_sec: interv_tm.get_sec(),
                            tv_nsec: interv_tm.get_nsec(),
                        },
                        it_value: timespec
                        {
                            tv_sec: interv_tm.get_sec(),
                            tv_nsec: interv_tm.get_nsec(),
                        },
                    }
        }
    }
}





#[cfg(all(target_family = "unix", feature = "enable_mio_compat"))]
pub mod mio_compat
{
    use std::{io, os::fd::{AsRawFd, RawFd}};

    use mio::{Token, unix::SourceFd};

    use crate::timer_portable::timer::TimerFdMioCompat;

    use super::TimerFd;

    impl mio::event::Source for TimerFd 
    {
        fn register(
            &mut self,
            registry: &mio::Registry,
            token: mio::Token,
            interests: mio::Interest,
        ) -> io::Result<()> 
        {
            return 
                SourceFd(&self.as_raw_fd()).register(registry, token, interests);
        }

        fn reregister(
            &mut self,
            registry: &mio::Registry,
            token: mio::Token,
            interests: mio::Interest,
        ) -> io::Result<()> 
        {
            return 
                SourceFd(&self.as_raw_fd()).reregister(registry, token, interests);
        }

        fn deregister(&mut self, registry: &mio::Registry) -> io::Result<()> 
        {
            return 
                SourceFd(&self.as_raw_fd()).deregister(registry)
        }
    }

    
    impl PartialEq<Token> for TimerFd
    {
        fn eq(&self, other: &Token) -> bool 
        {
            return self.as_raw_fd() == other.0 as RawFd;
        }
    }

    impl TimerFdMioCompat for TimerFd
    { 
        fn get_token(&self) -> Token
        {
            return Token(self.as_raw_fd() as usize);
        }
    }
}