devela 0.27.0

A development layer of coherence.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

// devela::sys::os::linux::time::timespec
//
//! Time value representation.
//!
//! Defines the [`LinuxTimespec`] structure used to represent time values
//! with second and nanosecond precision.
//

#![cfg_attr(not(feature = "unsafe_syscall"), allow(dead_code))]

use crate::{
    Cast, ConstInit, Display, Duration, FmtResult, Formatter, Overflow, format_buf, unwrap,
};

use crate::TimeDelta;

#[doc = crate::_tags!(linux time)]
/// Represents the [`timespec`] structure from libc. Time in seconds and nanoseconds.
#[doc = crate::_doc_location!("sys/os/linux")]
///
/// [`timespec`]: https://man7.org/linux/man-pages/man3/timespec.3type.html
#[derive(Clone, Copy, Debug, Default, PartialEq)]
#[repr(C)]
#[must_use]
pub struct LinuxTimespec {
    /// Number of whole seconds.
    pub tv_sec: isize,
    /// Number of nanoseconds.
    pub tv_nsec: isize,
}
impl ConstInit for LinuxTimespec {
    const INIT: Self = Self::new(0, 0);
}
impl Display for LinuxTimespec {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult<()> {
        // write!(f, "{}s {}ns", self.tv_sec, self.tv_nsec)
        let mut buf = [0u8; 64];
        let s = format_buf![&mut buf, "{}s {}ns", self.tv_sec, self.tv_nsec].unwrap();
        f.write_str(s)
    }
}

impl LinuxTimespec {
    /// Returns a new `LinuxTimespec` with the given `seconds` and `nanoseconds`.
    pub const fn new(seconds: isize, nanoseconds: isize) -> Self {
        Self { tv_sec: seconds, tv_nsec: nanoseconds }
    }

    /// Returns a new `LinuxTimespec` with the given `duration`.
    pub const fn try_with_duration(duration: Duration) -> Result<Self, Overflow> {
        Ok(Self {
            tv_sec: unwrap![ok? Cast(duration.as_secs()).checked_cast_to_isize()],
            tv_nsec: unwrap![ok? Cast(duration.subsec_nanos()).checked_cast_to_isize()],
        })
    }
    /// Returns a new `LinuxTimespec` with the given `duration`.
    pub const fn with_saturating_duration(duration: Duration) -> Self {
        Self {
            tv_sec: duration.as_secs() as isize,
            tv_nsec: duration.subsec_nanos() as isize,
        }
    }

    /// Returns a new `LinuxTimespec` with the given `time_delta`.
    pub const fn try_with_time_delta(time_delta: TimeDelta) -> Result<Self, Overflow> {
        Ok(Self {
            tv_sec: unwrap![ok? Cast(time_delta.as_secs()).checked_cast_to_isize()],
            tv_nsec: unwrap![ok? Cast(time_delta.subsec_nanos()).checked_cast_to_isize()],
        })
    }
    /// Returns a new `LinuxTimespec` with the given `time_delta`.
    pub const fn with_saturating_time_delta(time_delta: TimeDelta) -> Self {
        Self {
            tv_sec: time_delta.as_secs() as isize,
            tv_nsec: time_delta.subsec_nanos() as isize,
        }
    }

    /// Returns a raw pointer to self.
    pub const fn as_ptr(&self) -> *const Self {
        self as *const Self
    }

    /// Returns a raw mutable pointer to self.
    pub const fn as_mut_ptr(&mut self) -> *mut Self {
        self as *mut Self
    }

    /// Converts to a `Duration`.
    pub const fn try_to_duration(&self) -> Result<Duration, Overflow> {
        Ok(Duration::new(
            unwrap![ok? Cast(self.tv_sec).checked_cast_to_u64()],
            unwrap![ok? Cast(self.tv_nsec).checked_cast_to_u32()],
        ))
    }
    #[must_use]
    /// Converts to a `Duration`, saturating on overflow.
    pub const fn to_saturating_duration(&self) -> Duration {
        Duration::new(
            Cast(self.tv_sec).saturating_cast_to_u64(),
            Cast(self.tv_nsec).saturating_cast_to_u32(),
        )
    }

    /// Converts to a `TimeDelta`.
    pub const fn try_to_time_delta(&self) -> Result<TimeDelta, Overflow> {
        Ok(TimeDelta::new(
            unwrap![ok? Cast(self.tv_sec).checked_cast_to_i64()],
            unwrap![ok? Cast(self.tv_nsec).checked_cast_to_i32()],
        ))
    }
    #[must_use]
    /// Converts to a `TimeDelta`, saturating on overflow.
    pub const fn to_saturating_time_delta(&self) -> TimeDelta {
        TimeDelta::new(
            Cast(self.tv_sec).saturating_cast_to_i64(),
            Cast(self.tv_nsec).saturating_cast_to_i32(),
        )
    }
}

impl TryFrom<Duration> for LinuxTimespec {
    type Error = Overflow;
    fn try_from(duration: Duration) -> Result<Self, Self::Error> {
        Self::try_with_duration(duration)
    }
}
impl TryFrom<LinuxTimespec> for Duration {
    type Error = Overflow;
    fn try_from(timespec: LinuxTimespec) -> Result<Self, Self::Error> {
        timespec.try_to_duration()
    }
}
impl TryFrom<TimeDelta> for LinuxTimespec {
    type Error = Overflow;
    fn try_from(time_delta: TimeDelta) -> Result<Self, Self::Error> {
        Self::try_with_time_delta(time_delta)
    }
}
impl TryFrom<LinuxTimespec> for TimeDelta {
    type Error = Overflow;
    fn try_from(timespec: LinuxTimespec) -> Result<Self, Self::Error> {
        timespec.try_to_time_delta()
    }
}