satellite_datetime/earth/
iso8601.rs1use crate::earth::CivilUtc;
4use crate::error::{Error, Result};
5use crate::instant::Instant;
6
7pub 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
107pub 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 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}