Skip to main content

satellite_datetime/earth/
iso8601.rs

1//! ISO 8601 / RFC 3339 parse and format. Leap second `23:59:60` is accepted.
2
3use crate::earth::CivilUtc;
4use crate::error::{Error, Result};
5use crate::instant::Instant;
6
7/// Parse `YYYY-MM-DDTHH:MM:SS[.frac]Z` or with `±HH:MM` offset (interpreted as UTC after applying offset).
8pub fn parse_rfc3339(s: &str) -> Result<Instant> {
9    let b = s.as_bytes();
10    if b.len() < 20 {
11        return Err(Error::Parse);
12    }
13    let year = parse_n(&b[0..4])? as i32;
14    if b[4] != b'-' || b[7] != b'-' {
15        return Err(Error::Parse);
16    }
17    let month = parse_n(&b[5..7])? as u8;
18    let day = parse_n(&b[8..10])? as u8;
19    if b[10] != b'T' && b[10] != b't' && b[10] != b' ' {
20        return Err(Error::Parse);
21    }
22    let hour = parse_n(&b[11..13])? as u8;
23    if b[13] != b':' {
24        return Err(Error::Parse);
25    }
26    let minute = parse_n(&b[14..16])? as u8;
27    if b[16] != b':' {
28        return Err(Error::Parse);
29    }
30    let second = parse_n(&b[17..19])? as u8;
31    let mut i = 19;
32    let mut nanosecond = 0u32;
33    if i < b.len() && b[i] == b'.' {
34        i += 1;
35        let start = i;
36        while i < b.len() && b[i].is_ascii_digit() {
37            i += 1;
38        }
39        let frac = core::str::from_utf8(&b[start..i]).map_err(|_| Error::Parse)?;
40        if frac.is_empty() || frac.len() > 9 {
41            return Err(Error::Parse);
42        }
43        let mut f = 0u32;
44        for (k, ch) in frac.bytes().enumerate() {
45            f += (ch - b'0') as u32 * 10u32.pow(8 - k as u32);
46        }
47        nanosecond = f;
48    }
49    if i >= b.len() {
50        return Err(Error::Parse);
51    }
52    let (off_h, off_m, sign) = if b[i] == b'Z' || b[i] == b'z' {
53        if i + 1 != b.len() {
54            return Err(Error::Parse);
55        }
56        (0, 0, 1i32)
57    } else if b[i] == b'+' || b[i] == b'-' {
58        let sign = if b[i] == b'+' { 1i32 } else { -1 };
59        i += 1;
60        if i + 2 > b.len() {
61            return Err(Error::Parse);
62        }
63        let oh = parse_n(&b[i..i + 2])? as i32;
64        i += 2;
65        let om = if i < b.len() && b[i] == b':' {
66            i += 1;
67            if i + 2 > b.len() {
68                return Err(Error::Parse);
69            }
70            let m = parse_n(&b[i..i + 2])? as i32;
71            i += 2;
72            m
73        } else if i + 2 <= b.len() && b[i].is_ascii_digit() {
74            let m = parse_n(&b[i..i + 2])? as i32;
75            i += 2;
76            m
77        } else {
78            0
79        };
80        if i != b.len() {
81            return Err(Error::Parse);
82        }
83        (oh, om, sign)
84    } else {
85        return Err(Error::Parse);
86    };
87    let civil = CivilUtc::new(year, month, day, hour, minute, second, nanosecond)?;
88    let inst = civil.to_instant()?;
89    let off = sign * (off_h * 3600 + off_m * 60);
90    inst.checked_sub(crate::Duration::from_seconds(off as i64))
91}
92
93fn parse_n(b: &[u8]) -> Result<u32> {
94    let mut n = 0u32;
95    if b.is_empty() {
96        return Err(Error::Parse);
97    }
98    for c in b {
99        if !c.is_ascii_digit() {
100            return Err(Error::Parse);
101        }
102        n = n * 10 + (*c - b'0') as u32;
103    }
104    Ok(n)
105}
106
107/// Write RFC 3339 UTC (`...Z`) into `buf`. Returns bytes written.
108pub fn format_rfc3339(instant: Instant, buf: &mut [u8]) -> Result<usize> {
109    let c = instant.to_utc()?;
110    format_civil_z(c, buf)
111}
112
113pub(crate) fn format_civil_z(c: CivilUtc, buf: &mut [u8]) -> Result<usize> {
114    //  YYYY-MM-DDTHH:MM:SS.nnnnnnnnnZ  = 30 chars with 9-digit frac
115    const NEED: usize = 30;
116    if buf.len() < NEED {
117        return Err(Error::BufferTooSmall);
118    }
119    write_i32(buf, 0, 4, c.year);
120    buf[4] = b'-';
121    write_u32(buf, 5, 2, c.month as u32);
122    buf[7] = b'-';
123    write_u32(buf, 8, 2, c.day as u32);
124    buf[10] = b'T';
125    write_u32(buf, 11, 2, c.hour as u32);
126    buf[13] = b':';
127    write_u32(buf, 14, 2, c.minute as u32);
128    buf[16] = b':';
129    write_u32(buf, 17, 2, c.second as u32);
130    buf[19] = b'.';
131    write_u32(buf, 20, 9, c.nanosecond);
132    buf[29] = b'Z';
133    Ok(NEED)
134}
135
136fn write_u32(buf: &mut [u8], start: usize, width: usize, mut v: u32) {
137    for i in (0..width).rev() {
138        buf[start + i] = b'0' + (v % 10) as u8;
139        v /= 10;
140    }
141}
142
143fn write_i32(buf: &mut [u8], start: usize, width: usize, v: i32) {
144    write_u32(buf, start, width, v.unsigned_abs());
145    if v < 0 && width > 0 {
146        buf[start] = b'-';
147    }
148}
149
150#[cfg(all(test, feature = "alloc"))]
151mod tests {
152    use super::*;
153    use crate::earth::CivilUtc;
154
155    #[test]
156    fn roundtrip_z() {
157        let c = CivilUtc::new(2010, 7, 24, 11, 18, 7, 318_000_000).unwrap();
158        let inst = c.to_instant().unwrap();
159        let mut buf = [0u8; 32];
160        let n = format_rfc3339(inst, &mut buf).unwrap();
161        let s = core::str::from_utf8(&buf[..n]).unwrap();
162        let back = parse_rfc3339(s).unwrap();
163        assert_eq!(back, inst);
164    }
165
166    #[test]
167    fn parse_leap() {
168        let inst = parse_rfc3339("2016-12-31T23:59:60Z").unwrap();
169        assert_eq!(inst.to_utc().unwrap().second, 60);
170    }
171
172    #[test]
173    fn parse_offset() {
174        let a = parse_rfc3339("2010-07-24T11:18:07.318Z").unwrap();
175        let b = parse_rfc3339("2010-07-24T07:18:07.318-04:00").unwrap();
176        assert_eq!(a, b);
177    }
178}