| 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::MappedLocalTime<LocalTimeType>, Error> { |
| 87 |
match self { |
| 88 |
TransitionRule::Fixed(local_time_type) => { |
| 89 |
Ok(crate::MappedLocalTime::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::MappedLocalTime<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::MappedLocalTime::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::MappedLocalTime::Single(self.std)) |
| 264 |
} else if local_time > dst_start_transition_start |
| 265 |
&& local_time < dst_start_transition_end |
| 266 |
{ |
| 267 |
Ok(crate::MappedLocalTime::None) |
| 268 |
} else if local_time >= dst_start_transition_end |
| 269 |
&& local_time < dst_end_transition_end |
| 270 |
{ |
| 271 |
Ok(crate::MappedLocalTime::Single(self.dst)) |
| 272 |
} else if local_time >= dst_end_transition_end |
| 273 |
&& local_time <= dst_end_transition_start |
| 274 |
{ |
| 275 |
Ok(crate::MappedLocalTime::Ambiguous(self.std, self.dst)) |
| 276 |
} else { |
| 277 |
Ok(crate::MappedLocalTime::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::MappedLocalTime::Single(self.dst)) |
| 284 |
} else if local_time >= dst_end_transition_end |
| 285 |
&& local_time <= dst_end_transition_start |
| 286 |
{ |
| 287 |
Ok(crate::MappedLocalTime::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::MappedLocalTime::Single(self.std)) |
| 292 |
} else if local_time >= dst_start_transition_start |
| 293 |
&& local_time < dst_start_transition_end |
| 294 |
{ |
| 295 |
Ok(crate::MappedLocalTime::None) |
| 296 |
} else { |
| 297 |
Ok(crate::MappedLocalTime::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::MappedLocalTime::Single(self.std)) |
| 309 |
} else if local_time >= dst_start_transition_end |
| 310 |
&& local_time <= dst_start_transition_start |
| 311 |
{ |
| 312 |
Ok(crate::MappedLocalTime::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::MappedLocalTime::Single(self.dst)) |
| 317 |
} else if local_time >= dst_end_transition_start |
| 318 |
&& local_time < dst_end_transition_end |
| 319 |
{ |
| 320 |
Ok(crate::MappedLocalTime::None) |
| 321 |
} else { |
| 322 |
Ok(crate::MappedLocalTime::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::MappedLocalTime::Single(self.dst)) |
| 329 |
} else if local_time > dst_end_transition_start |
| 330 |
&& local_time < dst_end_transition_end |
| 331 |
{ |
| 332 |
Ok(crate::MappedLocalTime::None) |
| 333 |
} else if local_time >= dst_end_transition_end |
| 334 |
&& local_time < dst_start_transition_end |
| 335 |
{ |
| 336 |
Ok(crate::MappedLocalTime::Single(self.std)) |
| 337 |
} else if local_time >= dst_start_transition_end |
| 338 |
&& local_time <= dst_start_transition_start |
| 339 |
{ |
| 340 |
Ok(crate::MappedLocalTime::Ambiguous(self.dst, self.std)) |
| 341 |
} else { |
| 342 |
Ok(crate::MappedLocalTime::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(1)?; |
| 358 |
let unquoted = cursor.read_until(|&x| x == b'>')?; |
| 359 |
cursor.read_exact(1)?; |
| 360 |
Ok(unquoted) |
| 361 |
} |
| 362 |
|
| 363 |
/// Parse time zone offset |
| 364 |
fn parse_offset(cursor: &mut Cursor) -> Result<i32, Error> { |
| 365 |
let (sign, hour, minute, second) = 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, minute, second) = 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, hour, minute, second) = 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 = cursor.read_int()?; |
| 417 |
|
| 418 |
let mut minute = 0; |
| 419 |
let mut second = 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 = 1; |
| 435 |
if let Some(&c) = cursor.peek() { |
| 436 |
if c == b'+' || c == b'-' { |
| 437 |
cursor.read_exact(1)?; |
| 438 |
if c == b'-' { |
| 439 |
sign = -1; |
| 440 |
} |
| 441 |
} |
| 442 |
} |
| 443 |
|
| 444 |
let (hour, minute, second) = 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 |
} |