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