i0 0.1.0

thei.rs/i0 reference implementation written in rust
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

use std::cmp::Ordering;
use std::fmt::{self, Display, Formatter, LowerHex};
use time::{UtcDateTime, macros::utc_datetime};

const EPOCH: UtcDateTime = utc_datetime!(2025-06-01 00:00:00);

/// A point in time (in seconds) past the i0 epoch (2025-06-01 00:00:00)
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct Timestamp {
    seconds: u64,
}

impl Timestamp {
    /// Creates a new `Timestamp` from the current time
    ///
    /// # Panics
    ///
    /// This function panics if the system clock is before the epoch.
    /// Unless your system clock is misconfigured, that should never happen.
    pub fn new() -> Self {
        let now = UtcDateTime::now();
        let diff: u64 = (now - EPOCH)
            .whole_seconds()
            .try_into()
            .expect("clock is before timestamp epoch; your clock is likely wrong.");

        Self::from_seconds(diff)
    }

    /// Returns the seconds since epoch as a byte array in big-endian byte order
    pub fn to_bytes(self) -> [u8; 8] {
        self.as_seconds().to_be_bytes()
    }

    /// Creates a `Timestamp` from a byte array representing the seconds since epoch as a big-endian `u64`
    pub fn from_bytes(bytes: [u8; 8]) -> Self {
        u64::from_be_bytes(bytes).into()
    }

    /// Creates a `Timestamp` from the seconds since epoch as a big-endian unsigned integer
    pub fn from_seconds(seconds: u64) -> Self {
        Self { seconds }
    }

    /// Returns the seconds since epoch as an integer
    pub fn into_seconds(self) -> u64 {
        self.seconds
    }

    /// Extracts the seconds since epoch as an integer
    pub fn as_seconds(&self) -> &u64 {
        &self.seconds
    }

    /// Attempts to parse the hex-encoded seconds since epoch (as a u64) into a `Timestamp`
    pub fn try_from_hex(s: &str) -> Result<Self, std::num::ParseIntError> {
        u64::from_str_radix(s, 16).map(Self::from_seconds)
    }
}

impl Default for Timestamp {
    fn default() -> Self {
        Self::new()
    }
}

impl From<u64> for Timestamp {
    fn from(sec: u64) -> Self {
        Timestamp::from_seconds(sec)
    }
}

impl From<[u8; 8]> for Timestamp {
    fn from(bytes: [u8; 8]) -> Self {
        Self::from_bytes(bytes)
    }
}

impl TryFrom<&[u8]> for Timestamp {
    type Error = std::array::TryFromSliceError;

    fn try_from(slice: &[u8]) -> Result<Self, Self::Error> {
        let bytes: [u8; 8] = slice.try_into()?;
        Ok(bytes.into())
    }
}

impl TryFrom<Vec<u8>> for Timestamp {
    type Error = std::array::TryFromSliceError;

    fn try_from(vec: Vec<u8>) -> Result<Self, Self::Error> {
        vec.as_slice().try_into()
    }
}

impl From<Timestamp> for u64 {
    fn from(ts: Timestamp) -> Self {
        ts.into_seconds()
    }
}

impl From<Timestamp> for [u8; 8] {
    fn from(ts: Timestamp) -> Self {
        ts.to_bytes()
    }
}

impl From<Timestamp> for Vec<u8> {
    fn from(ts: Timestamp) -> Self {
        ts.to_bytes().into()
    }
}

impl LowerHex for Timestamp {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{:x}", self.as_seconds())?;
        Ok(())
    }
}

impl Display for Timestamp {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        LowerHex::fmt(&self, f)
    }
}

impl Ord for Timestamp {
    fn cmp(&self, other: &Self) -> Ordering {
        self.as_seconds().cmp(other.as_seconds())
    }
}

impl PartialOrd for Timestamp {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}