1 | use std::cmp::Ordering; |
2 | |
3 | use super::parser::Cursor; |
4 | use super::timezone::{LocalTimeType, SECONDS_PER_WEEK}; |
5 | use super::{ |
6 | Error, CUMUL_DAY_IN_MONTHS_NORMAL_YEAR, DAYS_PER_WEEK, DAY_IN_MONTHS_NORMAL_YEAR, |
7 | SECONDS_PER_DAY, |
8 | }; |
9 | |
10 | /// Transition rule |
11 | #[derive (Debug, Copy, Clone, Eq, PartialEq)] |
12 | pub(super) enum TransitionRule { |
13 | /// Fixed local time type |
14 | Fixed(LocalTimeType), |
15 | /// Alternate local time types |
16 | Alternate(AlternateTime), |
17 | } |
18 | |
19 | impl TransitionRule { |
20 | /// Parse a POSIX TZ string containing a time zone description, as described in [the POSIX documentation of the `TZ` environment variable](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html). |
21 | /// |
22 | /// TZ string extensions from [RFC 8536](https://datatracker.ietf.org/doc/html/rfc8536#section-3.3.1) may be used. |
23 | pub(super) fn from_tz_string( |
24 | tz_string: &[u8], |
25 | use_string_extensions: bool, |
26 | ) -> Result<Self, Error> { |
27 | let mut cursor = Cursor::new(tz_string); |
28 | |
29 | let std_time_zone = Some(parse_name(&mut cursor)?); |
30 | let std_offset = parse_offset(&mut cursor)?; |
31 | |
32 | if cursor.is_empty() { |
33 | return Ok(LocalTimeType::new(-std_offset, false, std_time_zone)?.into()); |
34 | } |
35 | |
36 | let dst_time_zone = Some(parse_name(&mut cursor)?); |
37 | |
38 | let dst_offset = match cursor.peek() { |
39 | Some(&b',' ) => std_offset - 3600, |
40 | Some(_) => parse_offset(&mut cursor)?, |
41 | None => { |
42 | return Err(Error::UnsupportedTzString("DST start and end rules must be provided" )) |
43 | } |
44 | }; |
45 | |
46 | if cursor.is_empty() { |
47 | return Err(Error::UnsupportedTzString("DST start and end rules must be provided" )); |
48 | } |
49 | |
50 | cursor.read_tag(b"," )?; |
51 | let (dst_start, dst_start_time) = RuleDay::parse(&mut cursor, use_string_extensions)?; |
52 | |
53 | cursor.read_tag(b"," )?; |
54 | let (dst_end, dst_end_time) = RuleDay::parse(&mut cursor, use_string_extensions)?; |
55 | |
56 | if !cursor.is_empty() { |
57 | return Err(Error::InvalidTzString("remaining data after parsing TZ string" )); |
58 | } |
59 | |
60 | Ok(AlternateTime::new( |
61 | LocalTimeType::new(-std_offset, false, std_time_zone)?, |
62 | LocalTimeType::new(-dst_offset, true, dst_time_zone)?, |
63 | dst_start, |
64 | dst_start_time, |
65 | dst_end, |
66 | dst_end_time, |
67 | )? |
68 | .into()) |
69 | } |
70 | |
71 | /// Find the local time type associated to the transition rule at the specified Unix time in seconds |
72 | pub(super) fn find_local_time_type(&self, unix_time: i64) -> Result<&LocalTimeType, Error> { |
73 | match self { |
74 | TransitionRule::Fixed(local_time_type) => Ok(local_time_type), |
75 | TransitionRule::Alternate(alternate_time) => { |
76 | alternate_time.find_local_time_type(unix_time) |
77 | } |
78 | } |
79 | } |
80 | |
81 | /// Find the local time type associated to the transition rule at the specified Unix time in seconds |
82 | pub(super) fn find_local_time_type_from_local( |
83 | &self, |
84 | local_time: i64, |
85 | year: i32, |
86 | ) -> Result<crate::LocalResult<LocalTimeType>, Error> { |
87 | match self { |
88 | TransitionRule::Fixed(local_time_type) => { |
89 | Ok(crate::LocalResult::Single(*local_time_type)) |
90 | } |
91 | TransitionRule::Alternate(alternate_time) => { |
92 | alternate_time.find_local_time_type_from_local(local_time, year) |
93 | } |
94 | } |
95 | } |
96 | } |
97 | |
98 | impl From<LocalTimeType> for TransitionRule { |
99 | fn from(inner: LocalTimeType) -> Self { |
100 | TransitionRule::Fixed(inner) |
101 | } |
102 | } |
103 | |
104 | impl From<AlternateTime> for TransitionRule { |
105 | fn from(inner: AlternateTime) -> Self { |
106 | TransitionRule::Alternate(inner) |
107 | } |
108 | } |
109 | |
110 | /// Transition rule representing alternate local time types |
111 | #[derive (Debug, Copy, Clone, Eq, PartialEq)] |
112 | pub(super) struct AlternateTime { |
113 | /// Local time type for standard time |
114 | pub(super) std: LocalTimeType, |
115 | /// Local time type for Daylight Saving Time |
116 | pub(super) dst: LocalTimeType, |
117 | /// Start day of Daylight Saving Time |
118 | dst_start: RuleDay, |
119 | /// Local start day time of Daylight Saving Time, in seconds |
120 | dst_start_time: i32, |
121 | /// End day of Daylight Saving Time |
122 | dst_end: RuleDay, |
123 | /// Local end day time of Daylight Saving Time, in seconds |
124 | dst_end_time: i32, |
125 | } |
126 | |
127 | impl AlternateTime { |
128 | /// Construct a transition rule representing alternate local time types |
129 | const fn new( |
130 | std: LocalTimeType, |
131 | dst: LocalTimeType, |
132 | dst_start: RuleDay, |
133 | dst_start_time: i32, |
134 | dst_end: RuleDay, |
135 | dst_end_time: i32, |
136 | ) -> Result<Self, Error> { |
137 | // Overflow is not possible |
138 | if !((dst_start_time as i64).abs() < SECONDS_PER_WEEK |
139 | && (dst_end_time as i64).abs() < SECONDS_PER_WEEK) |
140 | { |
141 | return Err(Error::TransitionRule("invalid DST start or end time" )); |
142 | } |
143 | |
144 | Ok(Self { std, dst, dst_start, dst_start_time, dst_end, dst_end_time }) |
145 | } |
146 | |
147 | /// Find the local time type associated to the alternate transition rule at the specified Unix time in seconds |
148 | fn find_local_time_type(&self, unix_time: i64) -> Result<&LocalTimeType, Error> { |
149 | // Overflow is not possible |
150 | let dst_start_time_in_utc = self.dst_start_time as i64 - self.std.ut_offset as i64; |
151 | let dst_end_time_in_utc = self.dst_end_time as i64 - self.dst.ut_offset as i64; |
152 | |
153 | let current_year = match UtcDateTime::from_timespec(unix_time) { |
154 | Ok(dt) => dt.year, |
155 | Err(error) => return Err(error), |
156 | }; |
157 | |
158 | // Check if the current year is valid for the following computations |
159 | if !(i32::min_value() + 2 <= current_year && current_year <= i32::max_value() - 2) { |
160 | return Err(Error::OutOfRange("out of range date time" )); |
161 | } |
162 | |
163 | let current_year_dst_start_unix_time = |
164 | self.dst_start.unix_time(current_year, dst_start_time_in_utc); |
165 | let current_year_dst_end_unix_time = |
166 | self.dst_end.unix_time(current_year, dst_end_time_in_utc); |
167 | |
168 | // Check DST start/end Unix times for previous/current/next years to support for transition day times outside of [0h, 24h] range |
169 | let is_dst = |
170 | match Ord::cmp(¤t_year_dst_start_unix_time, ¤t_year_dst_end_unix_time) { |
171 | Ordering::Less | Ordering::Equal => { |
172 | if unix_time < current_year_dst_start_unix_time { |
173 | let previous_year_dst_end_unix_time = |
174 | self.dst_end.unix_time(current_year - 1, dst_end_time_in_utc); |
175 | if unix_time < previous_year_dst_end_unix_time { |
176 | let previous_year_dst_start_unix_time = |
177 | self.dst_start.unix_time(current_year - 1, dst_start_time_in_utc); |
178 | previous_year_dst_start_unix_time <= unix_time |
179 | } else { |
180 | false |
181 | } |
182 | } else if unix_time < current_year_dst_end_unix_time { |
183 | true |
184 | } else { |
185 | let next_year_dst_start_unix_time = |
186 | self.dst_start.unix_time(current_year + 1, dst_start_time_in_utc); |
187 | if next_year_dst_start_unix_time <= unix_time { |
188 | let next_year_dst_end_unix_time = |
189 | self.dst_end.unix_time(current_year + 1, dst_end_time_in_utc); |
190 | unix_time < next_year_dst_end_unix_time |
191 | } else { |
192 | false |
193 | } |
194 | } |
195 | } |
196 | Ordering::Greater => { |
197 | if unix_time < current_year_dst_end_unix_time { |
198 | let previous_year_dst_start_unix_time = |
199 | self.dst_start.unix_time(current_year - 1, dst_start_time_in_utc); |
200 | if unix_time < previous_year_dst_start_unix_time { |
201 | let previous_year_dst_end_unix_time = |
202 | self.dst_end.unix_time(current_year - 1, dst_end_time_in_utc); |
203 | unix_time < previous_year_dst_end_unix_time |
204 | } else { |
205 | true |
206 | } |
207 | } else if unix_time < current_year_dst_start_unix_time { |
208 | false |
209 | } else { |
210 | let next_year_dst_end_unix_time = |
211 | self.dst_end.unix_time(current_year + 1, dst_end_time_in_utc); |
212 | if next_year_dst_end_unix_time <= unix_time { |
213 | let next_year_dst_start_unix_time = |
214 | self.dst_start.unix_time(current_year + 1, dst_start_time_in_utc); |
215 | next_year_dst_start_unix_time <= unix_time |
216 | } else { |
217 | true |
218 | } |
219 | } |
220 | } |
221 | }; |
222 | |
223 | if is_dst { |
224 | Ok(&self.dst) |
225 | } else { |
226 | Ok(&self.std) |
227 | } |
228 | } |
229 | |
230 | fn find_local_time_type_from_local( |
231 | &self, |
232 | local_time: i64, |
233 | current_year: i32, |
234 | ) -> Result<crate::LocalResult<LocalTimeType>, Error> { |
235 | // Check if the current year is valid for the following computations |
236 | if !(i32::min_value() + 2 <= current_year && current_year <= i32::max_value() - 2) { |
237 | return Err(Error::OutOfRange("out of range date time" )); |
238 | } |
239 | |
240 | let dst_start_transition_start = |
241 | self.dst_start.unix_time(current_year, 0) + i64::from(self.dst_start_time); |
242 | let dst_start_transition_end = self.dst_start.unix_time(current_year, 0) |
243 | + i64::from(self.dst_start_time) |
244 | + i64::from(self.dst.ut_offset) |
245 | - i64::from(self.std.ut_offset); |
246 | |
247 | let dst_end_transition_start = |
248 | self.dst_end.unix_time(current_year, 0) + i64::from(self.dst_end_time); |
249 | let dst_end_transition_end = self.dst_end.unix_time(current_year, 0) |
250 | + i64::from(self.dst_end_time) |
251 | + i64::from(self.std.ut_offset) |
252 | - i64::from(self.dst.ut_offset); |
253 | |
254 | match self.std.ut_offset.cmp(&self.dst.ut_offset) { |
255 | Ordering::Equal => Ok(crate::LocalResult::Single(self.std)), |
256 | Ordering::Less => { |
257 | if self.dst_start.transition_date(current_year).0 |
258 | < self.dst_end.transition_date(current_year).0 |
259 | { |
260 | // northern hemisphere |
261 | // For the DST END transition, the `start` happens at a later timestamp than the `end`. |
262 | if local_time <= dst_start_transition_start { |
263 | Ok(crate::LocalResult::Single(self.std)) |
264 | } else if local_time > dst_start_transition_start |
265 | && local_time < dst_start_transition_end |
266 | { |
267 | Ok(crate::LocalResult::None) |
268 | } else if local_time >= dst_start_transition_end |
269 | && local_time < dst_end_transition_end |
270 | { |
271 | Ok(crate::LocalResult::Single(self.dst)) |
272 | } else if local_time >= dst_end_transition_end |
273 | && local_time <= dst_end_transition_start |
274 | { |
275 | Ok(crate::LocalResult::Ambiguous(self.std, self.dst)) |
276 | } else { |
277 | Ok(crate::LocalResult::Single(self.std)) |
278 | } |
279 | } else { |
280 | // southern hemisphere regular DST |
281 | // For the DST END transition, the `start` happens at a later timestamp than the `end`. |
282 | if local_time < dst_end_transition_end { |
283 | Ok(crate::LocalResult::Single(self.dst)) |
284 | } else if local_time >= dst_end_transition_end |
285 | && local_time <= dst_end_transition_start |
286 | { |
287 | Ok(crate::LocalResult::Ambiguous(self.std, self.dst)) |
288 | } else if local_time > dst_end_transition_end |
289 | && local_time < dst_start_transition_start |
290 | { |
291 | Ok(crate::LocalResult::Single(self.std)) |
292 | } else if local_time >= dst_start_transition_start |
293 | && local_time < dst_start_transition_end |
294 | { |
295 | Ok(crate::LocalResult::None) |
296 | } else { |
297 | Ok(crate::LocalResult::Single(self.dst)) |
298 | } |
299 | } |
300 | } |
301 | Ordering::Greater => { |
302 | if self.dst_start.transition_date(current_year).0 |
303 | < self.dst_end.transition_date(current_year).0 |
304 | { |
305 | // southern hemisphere reverse DST |
306 | // For the DST END transition, the `start` happens at a later timestamp than the `end`. |
307 | if local_time < dst_start_transition_end { |
308 | Ok(crate::LocalResult::Single(self.std)) |
309 | } else if local_time >= dst_start_transition_end |
310 | && local_time <= dst_start_transition_start |
311 | { |
312 | Ok(crate::LocalResult::Ambiguous(self.dst, self.std)) |
313 | } else if local_time > dst_start_transition_start |
314 | && local_time < dst_end_transition_start |
315 | { |
316 | Ok(crate::LocalResult::Single(self.dst)) |
317 | } else if local_time >= dst_end_transition_start |
318 | && local_time < dst_end_transition_end |
319 | { |
320 | Ok(crate::LocalResult::None) |
321 | } else { |
322 | Ok(crate::LocalResult::Single(self.std)) |
323 | } |
324 | } else { |
325 | // northern hemisphere reverse DST |
326 | // For the DST END transition, the `start` happens at a later timestamp than the `end`. |
327 | if local_time <= dst_end_transition_start { |
328 | Ok(crate::LocalResult::Single(self.dst)) |
329 | } else if local_time > dst_end_transition_start |
330 | && local_time < dst_end_transition_end |
331 | { |
332 | Ok(crate::LocalResult::None) |
333 | } else if local_time >= dst_end_transition_end |
334 | && local_time < dst_start_transition_end |
335 | { |
336 | Ok(crate::LocalResult::Single(self.std)) |
337 | } else if local_time >= dst_start_transition_end |
338 | && local_time <= dst_start_transition_start |
339 | { |
340 | Ok(crate::LocalResult::Ambiguous(self.dst, self.std)) |
341 | } else { |
342 | Ok(crate::LocalResult::Single(self.dst)) |
343 | } |
344 | } |
345 | } |
346 | } |
347 | } |
348 | } |
349 | |
350 | /// Parse time zone name |
351 | fn parse_name<'a>(cursor: &mut Cursor<'a>) -> Result<&'a [u8], Error> { |
352 | match cursor.peek() { |
353 | Some(b'<' ) => {} |
354 | _ => return Ok(cursor.read_while(u8::is_ascii_alphabetic)?), |
355 | } |
356 | |
357 | cursor.read_exact(count:1)?; |
358 | let unquoted: &[u8] = cursor.read_until(|&x: u8| x == b'>' )?; |
359 | cursor.read_exact(count:1)?; |
360 | Ok(unquoted) |
361 | } |
362 | |
363 | /// Parse time zone offset |
364 | fn parse_offset(cursor: &mut Cursor) -> Result<i32, Error> { |
365 | let (sign: i32, hour: i32, minute: i32, second: i32) = parse_signed_hhmmss(cursor)?; |
366 | |
367 | if !(0..=24).contains(&hour) { |
368 | return Err(Error::InvalidTzString("invalid offset hour" )); |
369 | } |
370 | if !(0..=59).contains(&minute) { |
371 | return Err(Error::InvalidTzString("invalid offset minute" )); |
372 | } |
373 | if !(0..=59).contains(&second) { |
374 | return Err(Error::InvalidTzString("invalid offset second" )); |
375 | } |
376 | |
377 | Ok(sign * (hour * 3600 + minute * 60 + second)) |
378 | } |
379 | |
380 | /// Parse transition rule time |
381 | fn parse_rule_time(cursor: &mut Cursor) -> Result<i32, Error> { |
382 | let (hour: i32, minute: i32, second: i32) = parse_hhmmss(cursor)?; |
383 | |
384 | if !(0..=24).contains(&hour) { |
385 | return Err(Error::InvalidTzString("invalid day time hour" )); |
386 | } |
387 | if !(0..=59).contains(&minute) { |
388 | return Err(Error::InvalidTzString("invalid day time minute" )); |
389 | } |
390 | if !(0..=59).contains(&second) { |
391 | return Err(Error::InvalidTzString("invalid day time second" )); |
392 | } |
393 | |
394 | Ok(hour * 3600 + minute * 60 + second) |
395 | } |
396 | |
397 | /// Parse transition rule time with TZ string extensions |
398 | fn parse_rule_time_extended(cursor: &mut Cursor) -> Result<i32, Error> { |
399 | let (sign: i32, hour: i32, minute: i32, second: i32) = parse_signed_hhmmss(cursor)?; |
400 | |
401 | if !(-167..=167).contains(&hour) { |
402 | return Err(Error::InvalidTzString("invalid day time hour" )); |
403 | } |
404 | if !(0..=59).contains(&minute) { |
405 | return Err(Error::InvalidTzString("invalid day time minute" )); |
406 | } |
407 | if !(0..=59).contains(&second) { |
408 | return Err(Error::InvalidTzString("invalid day time second" )); |
409 | } |
410 | |
411 | Ok(sign * (hour * 3600 + minute * 60 + second)) |
412 | } |
413 | |
414 | /// Parse hours, minutes and seconds |
415 | fn parse_hhmmss(cursor: &mut Cursor) -> Result<(i32, i32, i32), Error> { |
416 | let hour: i32 = cursor.read_int()?; |
417 | |
418 | let mut minute: i32 = 0; |
419 | let mut second: i32 = 0; |
420 | |
421 | if cursor.read_optional_tag(b":" )? { |
422 | minute = cursor.read_int()?; |
423 | |
424 | if cursor.read_optional_tag(b":" )? { |
425 | second = cursor.read_int()?; |
426 | } |
427 | } |
428 | |
429 | Ok((hour, minute, second)) |
430 | } |
431 | |
432 | /// Parse signed hours, minutes and seconds |
433 | fn parse_signed_hhmmss(cursor: &mut Cursor) -> Result<(i32, i32, i32, i32), Error> { |
434 | let mut sign: i32 = 1; |
435 | if let Some(&c: u8) = cursor.peek() { |
436 | if c == b'+' || c == b'-' { |
437 | cursor.read_exact(count:1)?; |
438 | if c == b'-' { |
439 | sign = -1; |
440 | } |
441 | } |
442 | } |
443 | |
444 | let (hour: i32, minute: i32, second: i32) = parse_hhmmss(cursor)?; |
445 | Ok((sign, hour, minute, second)) |
446 | } |
447 | |
448 | /// Transition rule day |
449 | #[derive (Debug, Copy, Clone, Eq, PartialEq)] |
450 | enum RuleDay { |
451 | /// Julian day in `[1, 365]`, without taking occasional Feb 29 into account, which is not referenceable |
452 | Julian1WithoutLeap(u16), |
453 | /// Zero-based Julian day in `[0, 365]`, taking occasional Feb 29 into account |
454 | Julian0WithLeap(u16), |
455 | /// Day represented by a month, a month week and a week day |
456 | MonthWeekday { |
457 | /// Month in `[1, 12]` |
458 | month: u8, |
459 | /// Week of the month in `[1, 5]`, with `5` representing the last week of the month |
460 | week: u8, |
461 | /// Day of the week in `[0, 6]` from Sunday |
462 | week_day: u8, |
463 | }, |
464 | } |
465 | |
466 | impl RuleDay { |
467 | /// Parse transition rule |
468 | fn parse(cursor: &mut Cursor, use_string_extensions: bool) -> Result<(Self, i32), Error> { |
469 | let date = match cursor.peek() { |
470 | Some(b'M' ) => { |
471 | cursor.read_exact(1)?; |
472 | let month = cursor.read_int()?; |
473 | cursor.read_tag(b"." )?; |
474 | let week = cursor.read_int()?; |
475 | cursor.read_tag(b"." )?; |
476 | let week_day = cursor.read_int()?; |
477 | RuleDay::month_weekday(month, week, week_day)? |
478 | } |
479 | Some(b'J' ) => { |
480 | cursor.read_exact(1)?; |
481 | RuleDay::julian_1(cursor.read_int()?)? |
482 | } |
483 | _ => RuleDay::julian_0(cursor.read_int()?)?, |
484 | }; |
485 | |
486 | Ok(( |
487 | date, |
488 | match (cursor.read_optional_tag(b"/" )?, use_string_extensions) { |
489 | (false, _) => 2 * 3600, |
490 | (true, true) => parse_rule_time_extended(cursor)?, |
491 | (true, false) => parse_rule_time(cursor)?, |
492 | }, |
493 | )) |
494 | } |
495 | |
496 | /// Construct a transition rule day represented by a Julian day in `[1, 365]`, without taking occasional Feb 29 into account, which is not referenceable |
497 | fn julian_1(julian_day_1: u16) -> Result<Self, Error> { |
498 | if !(1..=365).contains(&julian_day_1) { |
499 | return Err(Error::TransitionRule("invalid rule day julian day" )); |
500 | } |
501 | |
502 | Ok(RuleDay::Julian1WithoutLeap(julian_day_1)) |
503 | } |
504 | |
505 | /// Construct a transition rule day represented by a zero-based Julian day in `[0, 365]`, taking occasional Feb 29 into account |
506 | const fn julian_0(julian_day_0: u16) -> Result<Self, Error> { |
507 | if julian_day_0 > 365 { |
508 | return Err(Error::TransitionRule("invalid rule day julian day" )); |
509 | } |
510 | |
511 | Ok(RuleDay::Julian0WithLeap(julian_day_0)) |
512 | } |
513 | |
514 | /// Construct a transition rule day represented by a month, a month week and a week day |
515 | fn month_weekday(month: u8, week: u8, week_day: u8) -> Result<Self, Error> { |
516 | if !(1..=12).contains(&month) { |
517 | return Err(Error::TransitionRule("invalid rule day month" )); |
518 | } |
519 | |
520 | if !(1..=5).contains(&week) { |
521 | return Err(Error::TransitionRule("invalid rule day week" )); |
522 | } |
523 | |
524 | if week_day > 6 { |
525 | return Err(Error::TransitionRule("invalid rule day week day" )); |
526 | } |
527 | |
528 | Ok(RuleDay::MonthWeekday { month, week, week_day }) |
529 | } |
530 | |
531 | /// Get the transition date for the provided year |
532 | /// |
533 | /// ## Outputs |
534 | /// |
535 | /// * `month`: Month in `[1, 12]` |
536 | /// * `month_day`: Day of the month in `[1, 31]` |
537 | fn transition_date(&self, year: i32) -> (usize, i64) { |
538 | match *self { |
539 | RuleDay::Julian1WithoutLeap(year_day) => { |
540 | let year_day = year_day as i64; |
541 | |
542 | let month = match CUMUL_DAY_IN_MONTHS_NORMAL_YEAR.binary_search(&(year_day - 1)) { |
543 | Ok(x) => x + 1, |
544 | Err(x) => x, |
545 | }; |
546 | |
547 | let month_day = year_day - CUMUL_DAY_IN_MONTHS_NORMAL_YEAR[month - 1]; |
548 | |
549 | (month, month_day) |
550 | } |
551 | RuleDay::Julian0WithLeap(year_day) => { |
552 | let leap = is_leap_year(year) as i64; |
553 | |
554 | let cumul_day_in_months = [ |
555 | 0, |
556 | 31, |
557 | 59 + leap, |
558 | 90 + leap, |
559 | 120 + leap, |
560 | 151 + leap, |
561 | 181 + leap, |
562 | 212 + leap, |
563 | 243 + leap, |
564 | 273 + leap, |
565 | 304 + leap, |
566 | 334 + leap, |
567 | ]; |
568 | |
569 | let year_day = year_day as i64; |
570 | |
571 | let month = match cumul_day_in_months.binary_search(&year_day) { |
572 | Ok(x) => x + 1, |
573 | Err(x) => x, |
574 | }; |
575 | |
576 | let month_day = 1 + year_day - cumul_day_in_months[month - 1]; |
577 | |
578 | (month, month_day) |
579 | } |
580 | RuleDay::MonthWeekday { month: rule_month, week, week_day } => { |
581 | let leap = is_leap_year(year) as i64; |
582 | |
583 | let month = rule_month as usize; |
584 | |
585 | let mut day_in_month = DAY_IN_MONTHS_NORMAL_YEAR[month - 1]; |
586 | if month == 2 { |
587 | day_in_month += leap; |
588 | } |
589 | |
590 | let week_day_of_first_month_day = |
591 | (4 + days_since_unix_epoch(year, month, 1)).rem_euclid(DAYS_PER_WEEK); |
592 | let first_week_day_occurence_in_month = |
593 | 1 + (week_day as i64 - week_day_of_first_month_day).rem_euclid(DAYS_PER_WEEK); |
594 | |
595 | let mut month_day = |
596 | first_week_day_occurence_in_month + (week as i64 - 1) * DAYS_PER_WEEK; |
597 | if month_day > day_in_month { |
598 | month_day -= DAYS_PER_WEEK |
599 | } |
600 | |
601 | (month, month_day) |
602 | } |
603 | } |
604 | } |
605 | |
606 | /// Returns the UTC Unix time in seconds associated to the transition date for the provided year |
607 | fn unix_time(&self, year: i32, day_time_in_utc: i64) -> i64 { |
608 | let (month, month_day) = self.transition_date(year); |
609 | days_since_unix_epoch(year, month, month_day) * SECONDS_PER_DAY + day_time_in_utc |
610 | } |
611 | } |
612 | |
613 | /// UTC date time exprimed in the [proleptic gregorian calendar](https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar) |
614 | #[derive (Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)] |
615 | pub(crate) struct UtcDateTime { |
616 | /// Year |
617 | pub(crate) year: i32, |
618 | /// Month in `[1, 12]` |
619 | pub(crate) month: u8, |
620 | /// Day of the month in `[1, 31]` |
621 | pub(crate) month_day: u8, |
622 | /// Hours since midnight in `[0, 23]` |
623 | pub(crate) hour: u8, |
624 | /// Minutes in `[0, 59]` |
625 | pub(crate) minute: u8, |
626 | /// Seconds in `[0, 60]`, with a possible leap second |
627 | pub(crate) second: u8, |
628 | } |
629 | |
630 | impl UtcDateTime { |
631 | /// Construct a UTC date time from a Unix time in seconds and nanoseconds |
632 | pub(crate) fn from_timespec(unix_time: i64) -> Result<Self, Error> { |
633 | let seconds = match unix_time.checked_sub(UNIX_OFFSET_SECS) { |
634 | Some(seconds) => seconds, |
635 | None => return Err(Error::OutOfRange("out of range operation" )), |
636 | }; |
637 | |
638 | let mut remaining_days = seconds / SECONDS_PER_DAY; |
639 | let mut remaining_seconds = seconds % SECONDS_PER_DAY; |
640 | if remaining_seconds < 0 { |
641 | remaining_seconds += SECONDS_PER_DAY; |
642 | remaining_days -= 1; |
643 | } |
644 | |
645 | let mut cycles_400_years = remaining_days / DAYS_PER_400_YEARS; |
646 | remaining_days %= DAYS_PER_400_YEARS; |
647 | if remaining_days < 0 { |
648 | remaining_days += DAYS_PER_400_YEARS; |
649 | cycles_400_years -= 1; |
650 | } |
651 | |
652 | let cycles_100_years = Ord::min(remaining_days / DAYS_PER_100_YEARS, 3); |
653 | remaining_days -= cycles_100_years * DAYS_PER_100_YEARS; |
654 | |
655 | let cycles_4_years = Ord::min(remaining_days / DAYS_PER_4_YEARS, 24); |
656 | remaining_days -= cycles_4_years * DAYS_PER_4_YEARS; |
657 | |
658 | let remaining_years = Ord::min(remaining_days / DAYS_PER_NORMAL_YEAR, 3); |
659 | remaining_days -= remaining_years * DAYS_PER_NORMAL_YEAR; |
660 | |
661 | let mut year = OFFSET_YEAR |
662 | + remaining_years |
663 | + cycles_4_years * 4 |
664 | + cycles_100_years * 100 |
665 | + cycles_400_years * 400; |
666 | |
667 | let mut month = 0; |
668 | while month < DAY_IN_MONTHS_LEAP_YEAR_FROM_MARCH.len() { |
669 | let days = DAY_IN_MONTHS_LEAP_YEAR_FROM_MARCH[month]; |
670 | if remaining_days < days { |
671 | break; |
672 | } |
673 | remaining_days -= days; |
674 | month += 1; |
675 | } |
676 | month += 2; |
677 | |
678 | if month >= MONTHS_PER_YEAR as usize { |
679 | month -= MONTHS_PER_YEAR as usize; |
680 | year += 1; |
681 | } |
682 | month += 1; |
683 | |
684 | let month_day = 1 + remaining_days; |
685 | |
686 | let hour = remaining_seconds / SECONDS_PER_HOUR; |
687 | let minute = (remaining_seconds / SECONDS_PER_MINUTE) % MINUTES_PER_HOUR; |
688 | let second = remaining_seconds % SECONDS_PER_MINUTE; |
689 | |
690 | let year = match year >= i32::min_value() as i64 && year <= i32::max_value() as i64 { |
691 | true => year as i32, |
692 | false => return Err(Error::OutOfRange("i64 is out of range for i32" )), |
693 | }; |
694 | |
695 | Ok(Self { |
696 | year, |
697 | month: month as u8, |
698 | month_day: month_day as u8, |
699 | hour: hour as u8, |
700 | minute: minute as u8, |
701 | second: second as u8, |
702 | }) |
703 | } |
704 | } |
705 | |
706 | /// Number of nanoseconds in one second |
707 | const NANOSECONDS_PER_SECOND: u32 = 1_000_000_000; |
708 | /// Number of seconds in one minute |
709 | const SECONDS_PER_MINUTE: i64 = 60; |
710 | /// Number of seconds in one hour |
711 | const SECONDS_PER_HOUR: i64 = 3600; |
712 | /// Number of minutes in one hour |
713 | const MINUTES_PER_HOUR: i64 = 60; |
714 | /// Number of months in one year |
715 | const MONTHS_PER_YEAR: i64 = 12; |
716 | /// Number of days in a normal year |
717 | const DAYS_PER_NORMAL_YEAR: i64 = 365; |
718 | /// Number of days in 4 years (including 1 leap year) |
719 | const DAYS_PER_4_YEARS: i64 = DAYS_PER_NORMAL_YEAR * 4 + 1; |
720 | /// Number of days in 100 years (including 24 leap years) |
721 | const DAYS_PER_100_YEARS: i64 = DAYS_PER_NORMAL_YEAR * 100 + 24; |
722 | /// Number of days in 400 years (including 97 leap years) |
723 | const DAYS_PER_400_YEARS: i64 = DAYS_PER_NORMAL_YEAR * 400 + 97; |
724 | /// Unix time at `2000-03-01T00:00:00Z` (Wednesday) |
725 | const UNIX_OFFSET_SECS: i64 = 951868800; |
726 | /// Offset year |
727 | const OFFSET_YEAR: i64 = 2000; |
728 | /// Month days in a leap year from March |
729 | const DAY_IN_MONTHS_LEAP_YEAR_FROM_MARCH: [i64; 12] = |
730 | [31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 29]; |
731 | |
732 | /// Compute the number of days since Unix epoch (`1970-01-01T00:00:00Z`). |
733 | /// |
734 | /// ## Inputs |
735 | /// |
736 | /// * `year`: Year |
737 | /// * `month`: Month in `[1, 12]` |
738 | /// * `month_day`: Day of the month in `[1, 31]` |
739 | pub(crate) const fn days_since_unix_epoch(year: i32, month: usize, month_day: i64) -> i64 { |
740 | let is_leap_year = is_leap_year(year); |
741 | |
742 | let year = year as i64; |
743 | |
744 | let mut result = (year - 1970) * 365; |
745 | |
746 | if year >= 1970 { |
747 | result += (year - 1968) / 4; |
748 | result -= (year - 1900) / 100; |
749 | result += (year - 1600) / 400; |
750 | |
751 | if is_leap_year && month < 3 { |
752 | result -= 1; |
753 | } |
754 | } else { |
755 | result += (year - 1972) / 4; |
756 | result -= (year - 2000) / 100; |
757 | result += (year - 2000) / 400; |
758 | |
759 | if is_leap_year && month >= 3 { |
760 | result += 1; |
761 | } |
762 | } |
763 | |
764 | result += CUMUL_DAY_IN_MONTHS_NORMAL_YEAR[month - 1] + month_day - 1; |
765 | |
766 | result |
767 | } |
768 | |
769 | /// Check if a year is a leap year |
770 | pub(crate) const fn is_leap_year(year: i32) -> bool { |
771 | year % 400 == 0 || (year % 4 == 0 && year % 100 != 0) |
772 | } |
773 | |
774 | #[cfg (test)] |
775 | mod tests { |
776 | use super::super::timezone::Transition; |
777 | use super::super::{Error, TimeZone}; |
778 | use super::{AlternateTime, LocalTimeType, RuleDay, TransitionRule}; |
779 | |
780 | #[test ] |
781 | fn test_quoted() -> Result<(), Error> { |
782 | let transition_rule = TransitionRule::from_tz_string(b"<-03>+3<+03>-3,J1,J365" , false)?; |
783 | assert_eq!( |
784 | transition_rule, |
785 | AlternateTime::new( |
786 | LocalTimeType::new(-10800, false, Some(b"-03" ))?, |
787 | LocalTimeType::new(10800, true, Some(b"+03" ))?, |
788 | RuleDay::julian_1(1)?, |
789 | 7200, |
790 | RuleDay::julian_1(365)?, |
791 | 7200, |
792 | )? |
793 | .into() |
794 | ); |
795 | Ok(()) |
796 | } |
797 | |
798 | #[test ] |
799 | fn test_full() -> Result<(), Error> { |
800 | let tz_string = b"NZST-12:00:00NZDT-13:00:00,M10.1.0/02:00:00,M3.3.0/02:00:00" ; |
801 | let transition_rule = TransitionRule::from_tz_string(tz_string, false)?; |
802 | assert_eq!( |
803 | transition_rule, |
804 | AlternateTime::new( |
805 | LocalTimeType::new(43200, false, Some(b"NZST" ))?, |
806 | LocalTimeType::new(46800, true, Some(b"NZDT" ))?, |
807 | RuleDay::month_weekday(10, 1, 0)?, |
808 | 7200, |
809 | RuleDay::month_weekday(3, 3, 0)?, |
810 | 7200, |
811 | )? |
812 | .into() |
813 | ); |
814 | Ok(()) |
815 | } |
816 | |
817 | #[test ] |
818 | fn test_negative_dst() -> Result<(), Error> { |
819 | let tz_string = b"IST-1GMT0,M10.5.0,M3.5.0/1" ; |
820 | let transition_rule = TransitionRule::from_tz_string(tz_string, false)?; |
821 | assert_eq!( |
822 | transition_rule, |
823 | AlternateTime::new( |
824 | LocalTimeType::new(3600, false, Some(b"IST" ))?, |
825 | LocalTimeType::new(0, true, Some(b"GMT" ))?, |
826 | RuleDay::month_weekday(10, 5, 0)?, |
827 | 7200, |
828 | RuleDay::month_weekday(3, 5, 0)?, |
829 | 3600, |
830 | )? |
831 | .into() |
832 | ); |
833 | Ok(()) |
834 | } |
835 | |
836 | #[test ] |
837 | fn test_negative_hour() -> Result<(), Error> { |
838 | let tz_string = b"<-03>3<-02>,M3.5.0/-2,M10.5.0/-1" ; |
839 | assert!(TransitionRule::from_tz_string(tz_string, false).is_err()); |
840 | |
841 | assert_eq!( |
842 | TransitionRule::from_tz_string(tz_string, true)?, |
843 | AlternateTime::new( |
844 | LocalTimeType::new(-10800, false, Some(b"-03" ))?, |
845 | LocalTimeType::new(-7200, true, Some(b"-02" ))?, |
846 | RuleDay::month_weekday(3, 5, 0)?, |
847 | -7200, |
848 | RuleDay::month_weekday(10, 5, 0)?, |
849 | -3600, |
850 | )? |
851 | .into() |
852 | ); |
853 | Ok(()) |
854 | } |
855 | |
856 | #[test ] |
857 | fn test_all_year_dst() -> Result<(), Error> { |
858 | let tz_string = b"EST5EDT,0/0,J365/25" ; |
859 | assert!(TransitionRule::from_tz_string(tz_string, false).is_err()); |
860 | |
861 | assert_eq!( |
862 | TransitionRule::from_tz_string(tz_string, true)?, |
863 | AlternateTime::new( |
864 | LocalTimeType::new(-18000, false, Some(b"EST" ))?, |
865 | LocalTimeType::new(-14400, true, Some(b"EDT" ))?, |
866 | RuleDay::julian_0(0)?, |
867 | 0, |
868 | RuleDay::julian_1(365)?, |
869 | 90000, |
870 | )? |
871 | .into() |
872 | ); |
873 | Ok(()) |
874 | } |
875 | |
876 | #[test ] |
877 | fn test_v3_file() -> Result<(), Error> { |
878 | let bytes = b"TZif3 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\0\0\0\x04\0\0\x1c\x20\0\0IST \0TZif3 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\0\0\0\x01\0\0\0\0\0\0\0\x01\0\0\0\x01\0\0\0\x04\0\0\0\0\x7f\xe8\x17\x80\0\0\0\x1c\x20\0\0IST \0\x01\x01\x0aIST-2IDT,M3.4.4/26,M10.5.0 \x0a" ; |
879 | |
880 | let time_zone = TimeZone::from_tz_data(bytes)?; |
881 | |
882 | let time_zone_result = TimeZone::new( |
883 | vec![Transition::new(2145916800, 0)], |
884 | vec![LocalTimeType::new(7200, false, Some(b"IST" ))?], |
885 | Vec::new(), |
886 | Some(TransitionRule::from(AlternateTime::new( |
887 | LocalTimeType::new(7200, false, Some(b"IST" ))?, |
888 | LocalTimeType::new(10800, true, Some(b"IDT" ))?, |
889 | RuleDay::month_weekday(3, 4, 4)?, |
890 | 93600, |
891 | RuleDay::month_weekday(10, 5, 0)?, |
892 | 7200, |
893 | )?)), |
894 | )?; |
895 | |
896 | assert_eq!(time_zone, time_zone_result); |
897 | |
898 | Ok(()) |
899 | } |
900 | |
901 | #[test ] |
902 | fn test_rule_day() -> Result<(), Error> { |
903 | let rule_day_j1 = RuleDay::julian_1(60)?; |
904 | assert_eq!(rule_day_j1.transition_date(2000), (3, 1)); |
905 | assert_eq!(rule_day_j1.transition_date(2001), (3, 1)); |
906 | assert_eq!(rule_day_j1.unix_time(2000, 43200), 951912000); |
907 | |
908 | let rule_day_j0 = RuleDay::julian_0(59)?; |
909 | assert_eq!(rule_day_j0.transition_date(2000), (2, 29)); |
910 | assert_eq!(rule_day_j0.transition_date(2001), (3, 1)); |
911 | assert_eq!(rule_day_j0.unix_time(2000, 43200), 951825600); |
912 | |
913 | let rule_day_mwd = RuleDay::month_weekday(2, 5, 2)?; |
914 | assert_eq!(rule_day_mwd.transition_date(2000), (2, 29)); |
915 | assert_eq!(rule_day_mwd.transition_date(2001), (2, 27)); |
916 | assert_eq!(rule_day_mwd.unix_time(2000, 43200), 951825600); |
917 | assert_eq!(rule_day_mwd.unix_time(2001, 43200), 983275200); |
918 | |
919 | Ok(()) |
920 | } |
921 | |
922 | #[test ] |
923 | fn test_transition_rule() -> Result<(), Error> { |
924 | let transition_rule_fixed = TransitionRule::from(LocalTimeType::new(-36000, false, None)?); |
925 | assert_eq!(transition_rule_fixed.find_local_time_type(0)?.offset(), -36000); |
926 | |
927 | let transition_rule_dst = TransitionRule::from(AlternateTime::new( |
928 | LocalTimeType::new(43200, false, Some(b"NZST" ))?, |
929 | LocalTimeType::new(46800, true, Some(b"NZDT" ))?, |
930 | RuleDay::month_weekday(10, 1, 0)?, |
931 | 7200, |
932 | RuleDay::month_weekday(3, 3, 0)?, |
933 | 7200, |
934 | )?); |
935 | |
936 | assert_eq!(transition_rule_dst.find_local_time_type(953384399)?.offset(), 46800); |
937 | assert_eq!(transition_rule_dst.find_local_time_type(953384400)?.offset(), 43200); |
938 | assert_eq!(transition_rule_dst.find_local_time_type(970322399)?.offset(), 43200); |
939 | assert_eq!(transition_rule_dst.find_local_time_type(970322400)?.offset(), 46800); |
940 | |
941 | let transition_rule_negative_dst = TransitionRule::from(AlternateTime::new( |
942 | LocalTimeType::new(3600, false, Some(b"IST" ))?, |
943 | LocalTimeType::new(0, true, Some(b"GMT" ))?, |
944 | RuleDay::month_weekday(10, 5, 0)?, |
945 | 7200, |
946 | RuleDay::month_weekday(3, 5, 0)?, |
947 | 3600, |
948 | )?); |
949 | |
950 | assert_eq!(transition_rule_negative_dst.find_local_time_type(954032399)?.offset(), 0); |
951 | assert_eq!(transition_rule_negative_dst.find_local_time_type(954032400)?.offset(), 3600); |
952 | assert_eq!(transition_rule_negative_dst.find_local_time_type(972781199)?.offset(), 3600); |
953 | assert_eq!(transition_rule_negative_dst.find_local_time_type(972781200)?.offset(), 0); |
954 | |
955 | let transition_rule_negative_time_1 = TransitionRule::from(AlternateTime::new( |
956 | LocalTimeType::new(0, false, None)?, |
957 | LocalTimeType::new(0, true, None)?, |
958 | RuleDay::julian_0(100)?, |
959 | 0, |
960 | RuleDay::julian_0(101)?, |
961 | -86500, |
962 | )?); |
963 | |
964 | assert!(transition_rule_negative_time_1.find_local_time_type(8639899)?.is_dst()); |
965 | assert!(!transition_rule_negative_time_1.find_local_time_type(8639900)?.is_dst()); |
966 | assert!(!transition_rule_negative_time_1.find_local_time_type(8639999)?.is_dst()); |
967 | assert!(transition_rule_negative_time_1.find_local_time_type(8640000)?.is_dst()); |
968 | |
969 | let transition_rule_negative_time_2 = TransitionRule::from(AlternateTime::new( |
970 | LocalTimeType::new(-10800, false, Some(b"-03" ))?, |
971 | LocalTimeType::new(-7200, true, Some(b"-02" ))?, |
972 | RuleDay::month_weekday(3, 5, 0)?, |
973 | -7200, |
974 | RuleDay::month_weekday(10, 5, 0)?, |
975 | -3600, |
976 | )?); |
977 | |
978 | assert_eq!( |
979 | transition_rule_negative_time_2.find_local_time_type(954032399)?.offset(), |
980 | -10800 |
981 | ); |
982 | assert_eq!( |
983 | transition_rule_negative_time_2.find_local_time_type(954032400)?.offset(), |
984 | -7200 |
985 | ); |
986 | assert_eq!( |
987 | transition_rule_negative_time_2.find_local_time_type(972781199)?.offset(), |
988 | -7200 |
989 | ); |
990 | assert_eq!( |
991 | transition_rule_negative_time_2.find_local_time_type(972781200)?.offset(), |
992 | -10800 |
993 | ); |
994 | |
995 | let transition_rule_all_year_dst = TransitionRule::from(AlternateTime::new( |
996 | LocalTimeType::new(-18000, false, Some(b"EST" ))?, |
997 | LocalTimeType::new(-14400, true, Some(b"EDT" ))?, |
998 | RuleDay::julian_0(0)?, |
999 | 0, |
1000 | RuleDay::julian_1(365)?, |
1001 | 90000, |
1002 | )?); |
1003 | |
1004 | assert_eq!(transition_rule_all_year_dst.find_local_time_type(946702799)?.offset(), -14400); |
1005 | assert_eq!(transition_rule_all_year_dst.find_local_time_type(946702800)?.offset(), -14400); |
1006 | |
1007 | Ok(()) |
1008 | } |
1009 | |
1010 | #[test ] |
1011 | fn test_transition_rule_overflow() -> Result<(), Error> { |
1012 | let transition_rule_1 = TransitionRule::from(AlternateTime::new( |
1013 | LocalTimeType::new(-1, false, None)?, |
1014 | LocalTimeType::new(-1, true, None)?, |
1015 | RuleDay::julian_1(365)?, |
1016 | 0, |
1017 | RuleDay::julian_1(1)?, |
1018 | 0, |
1019 | )?); |
1020 | |
1021 | let transition_rule_2 = TransitionRule::from(AlternateTime::new( |
1022 | LocalTimeType::new(1, false, None)?, |
1023 | LocalTimeType::new(1, true, None)?, |
1024 | RuleDay::julian_1(365)?, |
1025 | 0, |
1026 | RuleDay::julian_1(1)?, |
1027 | 0, |
1028 | )?); |
1029 | |
1030 | let min_unix_time = -67768100567971200; |
1031 | let max_unix_time = 67767976233532799; |
1032 | |
1033 | assert!(matches!( |
1034 | transition_rule_1.find_local_time_type(min_unix_time), |
1035 | Err(Error::OutOfRange(_)) |
1036 | )); |
1037 | assert!(matches!( |
1038 | transition_rule_2.find_local_time_type(max_unix_time), |
1039 | Err(Error::OutOfRange(_)) |
1040 | )); |
1041 | |
1042 | Ok(()) |
1043 | } |
1044 | } |
1045 | |