From a0b8f38ab54ac451646aa00cd5e91b6c76f22a84 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Thu, 30 May 2024 05:57:19 +0200 Subject: Merging upstream version 1.72.1+dfsg1. Signed-off-by: Daniel Baumann --- vendor/time/src/time.rs | 154 ++++++++++++++++++++++++++---------------------- 1 file changed, 85 insertions(+), 69 deletions(-) (limited to 'vendor/time/src/time.rs') diff --git a/vendor/time/src/time.rs b/vendor/time/src/time.rs index 32fa97790..87b465bb9 100644 --- a/vendor/time/src/time.rs +++ b/vendor/time/src/time.rs @@ -6,6 +6,7 @@ use core::time::Duration as StdDuration; #[cfg(feature = "formatting")] use std::io; +use crate::convert::*; #[cfg(feature = "formatting")] use crate::formatting::Formattable; #[cfg(feature = "parsing")] @@ -71,10 +72,10 @@ impl Time { second: u8, nanosecond: u32, ) -> Self { - debug_assert!(hour < 24); - debug_assert!(minute < 60); - debug_assert!(second < 60); - debug_assert!(nanosecond < 1_000_000_000); + debug_assert!(hour < Hour.per(Day)); + debug_assert!(minute < Minute.per(Hour)); + debug_assert!(second < Second.per(Minute)); + debug_assert!(nanosecond < Nanosecond.per(Second)); Self { hour, @@ -99,9 +100,9 @@ impl Time { /// assert!(Time::from_hms(0, 0, 60).is_err()); // 60 isn't a valid second. /// ``` pub const fn from_hms(hour: u8, minute: u8, second: u8) -> Result { - ensure_value_in_range!(hour in 0 => 23); - ensure_value_in_range!(minute in 0 => 59); - ensure_value_in_range!(second in 0 => 59); + ensure_value_in_range!(hour in 0 => Hour.per(Day) - 1); + ensure_value_in_range!(minute in 0 => Minute.per(Hour) - 1); + ensure_value_in_range!(second in 0 => Second.per(Minute) - 1); Ok(Self::__from_hms_nanos_unchecked(hour, minute, second, 0)) } @@ -125,15 +126,15 @@ impl Time { second: u8, millisecond: u16, ) -> Result { - ensure_value_in_range!(hour in 0 => 23); - ensure_value_in_range!(minute in 0 => 59); - ensure_value_in_range!(second in 0 => 59); - ensure_value_in_range!(millisecond in 0 => 999); + ensure_value_in_range!(hour in 0 => Hour.per(Day) - 1); + ensure_value_in_range!(minute in 0 => Minute.per(Hour) - 1); + ensure_value_in_range!(second in 0 => Second.per(Minute) - 1); + ensure_value_in_range!(millisecond in 0 => Millisecond.per(Second) - 1); Ok(Self::__from_hms_nanos_unchecked( hour, minute, second, - millisecond as u32 * 1_000_000, + millisecond as u32 * Nanosecond.per(Millisecond), )) } @@ -157,15 +158,15 @@ impl Time { second: u8, microsecond: u32, ) -> Result { - ensure_value_in_range!(hour in 0 => 23); - ensure_value_in_range!(minute in 0 => 59); - ensure_value_in_range!(second in 0 => 59); - ensure_value_in_range!(microsecond in 0 => 999_999); + ensure_value_in_range!(hour in 0 => Hour.per(Day) - 1); + ensure_value_in_range!(minute in 0 => Minute.per(Hour) - 1); + ensure_value_in_range!(second in 0 => Second.per(Minute) - 1); + ensure_value_in_range!(microsecond in 0 => Microsecond.per(Second) - 1); Ok(Self::__from_hms_nanos_unchecked( hour, minute, second, - microsecond * 1_000, + microsecond * Nanosecond.per(Microsecond) as u32, )) } @@ -189,10 +190,10 @@ impl Time { second: u8, nanosecond: u32, ) -> Result { - ensure_value_in_range!(hour in 0 => 23); - ensure_value_in_range!(minute in 0 => 59); - ensure_value_in_range!(second in 0 => 59); - ensure_value_in_range!(nanosecond in 0 => 999_999_999); + ensure_value_in_range!(hour in 0 => Hour.per(Day) - 1); + ensure_value_in_range!(minute in 0 => Minute.per(Hour) - 1); + ensure_value_in_range!(second in 0 => Second.per(Minute) - 1); + ensure_value_in_range!(nanosecond in 0 => Nanosecond.per(Second) - 1); Ok(Self::__from_hms_nanos_unchecked( hour, minute, second, nanosecond, )) @@ -223,7 +224,7 @@ impl Time { self.hour, self.minute, self.second, - (self.nanosecond / 1_000_000) as u16, + (self.nanosecond / Nanosecond.per(Millisecond)) as u16, ) } @@ -238,7 +239,12 @@ impl Time { /// ); /// ``` pub const fn as_hms_micro(self) -> (u8, u8, u8, u32) { - (self.hour, self.minute, self.second, self.nanosecond / 1_000) + ( + self.hour, + self.minute, + self.second, + self.nanosecond / Nanosecond.per(Microsecond) as u32, + ) } /// Get the clock hour, minute, second, and nanosecond. @@ -304,7 +310,7 @@ impl Time { /// assert_eq!(time!(23:59:59.999).millisecond(), 999); /// ``` pub const fn millisecond(self) -> u16 { - (self.nanosecond / 1_000_000) as _ + (self.nanosecond / Nanosecond.per(Millisecond)) as _ } /// Get the microseconds within the second. @@ -317,7 +323,7 @@ impl Time { /// assert_eq!(time!(23:59:59.999_999).microsecond(), 999_999); /// ``` pub const fn microsecond(self) -> u32 { - self.nanosecond / 1_000 + self.nanosecond / Nanosecond.per(Microsecond) as u32 } /// Get the nanoseconds within the second. @@ -339,19 +345,21 @@ impl Time { /// the date is different. pub(crate) const fn adjusting_add(self, duration: Duration) -> (DateAdjustment, Self) { let mut nanoseconds = self.nanosecond as i32 + duration.subsec_nanoseconds(); - let mut seconds = self.second as i8 + (duration.whole_seconds() % 60) as i8; - let mut minutes = self.minute as i8 + (duration.whole_minutes() % 60) as i8; - let mut hours = self.hour as i8 + (duration.whole_hours() % 24) as i8; + let mut seconds = + self.second as i8 + (duration.whole_seconds() % Second.per(Minute) as i64) as i8; + let mut minutes = + self.minute as i8 + (duration.whole_minutes() % Minute.per(Hour) as i64) as i8; + let mut hours = self.hour as i8 + (duration.whole_hours() % Hour.per(Day) as i64) as i8; let mut date_adjustment = DateAdjustment::None; - cascade!(nanoseconds in 0..1_000_000_000 => seconds); - cascade!(seconds in 0..60 => minutes); - cascade!(minutes in 0..60 => hours); - if hours >= 24 { - hours -= 24; + cascade!(nanoseconds in 0..Nanosecond.per(Second) as _ => seconds); + cascade!(seconds in 0..Second.per(Minute) as _ => minutes); + cascade!(minutes in 0..Minute.per(Hour) as _ => hours); + if hours >= Hour.per(Day) as _ { + hours -= Hour.per(Day) as i8; date_adjustment = DateAdjustment::Next; } else if hours < 0 { - hours += 24; + hours += Hour.per(Day) as i8; date_adjustment = DateAdjustment::Previous; } @@ -370,19 +378,21 @@ impl Time { /// whether the date is different. pub(crate) const fn adjusting_sub(self, duration: Duration) -> (DateAdjustment, Self) { let mut nanoseconds = self.nanosecond as i32 - duration.subsec_nanoseconds(); - let mut seconds = self.second as i8 - (duration.whole_seconds() % 60) as i8; - let mut minutes = self.minute as i8 - (duration.whole_minutes() % 60) as i8; - let mut hours = self.hour as i8 - (duration.whole_hours() % 24) as i8; + let mut seconds = + self.second as i8 - (duration.whole_seconds() % Second.per(Minute) as i64) as i8; + let mut minutes = + self.minute as i8 - (duration.whole_minutes() % Minute.per(Hour) as i64) as i8; + let mut hours = self.hour as i8 - (duration.whole_hours() % Hour.per(Day) as i64) as i8; let mut date_adjustment = DateAdjustment::None; - cascade!(nanoseconds in 0..1_000_000_000 => seconds); - cascade!(seconds in 0..60 => minutes); - cascade!(minutes in 0..60 => hours); - if hours >= 24 { - hours -= 24; + cascade!(nanoseconds in 0..Nanosecond.per(Second) as _ => seconds); + cascade!(seconds in 0..Second.per(Minute) as _ => minutes); + cascade!(minutes in 0..Minute.per(Hour) as _ => hours); + if hours >= Hour.per(Day) as _ { + hours -= Hour.per(Day) as i8; date_adjustment = DateAdjustment::Next; } else if hours < 0 { - hours += 24; + hours += Hour.per(Day) as i8; date_adjustment = DateAdjustment::Previous; } @@ -401,16 +411,18 @@ impl Time { /// returning whether the date is the previous date as the first element of the tuple. pub(crate) const fn adjusting_add_std(self, duration: StdDuration) -> (bool, Self) { let mut nanosecond = self.nanosecond + duration.subsec_nanos(); - let mut second = self.second + (duration.as_secs() % 60) as u8; - let mut minute = self.minute + ((duration.as_secs() / 60) % 60) as u8; - let mut hour = self.hour + ((duration.as_secs() / 3_600) % 24) as u8; + let mut second = self.second + (duration.as_secs() % Second.per(Minute) as u64) as u8; + let mut minute = self.minute + + ((duration.as_secs() / Second.per(Minute) as u64) % Minute.per(Hour) as u64) as u8; + let mut hour = self.hour + + ((duration.as_secs() / Second.per(Hour) as u64) % Hour.per(Day) as u64) as u8; let mut is_next_day = false; - cascade!(nanosecond in 0..1_000_000_000 => second); - cascade!(second in 0..60 => minute); - cascade!(minute in 0..60 => hour); - if hour >= 24 { - hour -= 24; + cascade!(nanosecond in 0..Nanosecond.per(Second) => second); + cascade!(second in 0..Second.per(Minute) => minute); + cascade!(minute in 0..Minute.per(Hour) => hour); + if hour >= Hour.per(Day) { + hour -= Hour.per(Day); is_next_day = true; } @@ -424,16 +436,18 @@ impl Time { /// returning whether the date is the previous date as the first element of the tuple. pub(crate) const fn adjusting_sub_std(self, duration: StdDuration) -> (bool, Self) { let mut nanosecond = self.nanosecond as i32 - duration.subsec_nanos() as i32; - let mut second = self.second as i8 - (duration.as_secs() % 60) as i8; - let mut minute = self.minute as i8 - ((duration.as_secs() / 60) % 60) as i8; - let mut hour = self.hour as i8 - ((duration.as_secs() / 3_600) % 24) as i8; + let mut second = self.second as i8 - (duration.as_secs() % Second.per(Minute) as u64) as i8; + let mut minute = self.minute as i8 + - ((duration.as_secs() / Second.per(Minute) as u64) % Minute.per(Hour) as u64) as i8; + let mut hour = self.hour as i8 + - ((duration.as_secs() / Second.per(Hour) as u64) % Hour.per(Day) as u64) as i8; let mut is_previous_day = false; - cascade!(nanosecond in 0..1_000_000_000 => second); - cascade!(second in 0..60 => minute); - cascade!(minute in 0..60 => hour); + cascade!(nanosecond in 0..Nanosecond.per(Second) as _ => second); + cascade!(second in 0..Second.per(Minute) as _ => minute); + cascade!(minute in 0..Minute.per(Hour) as _ => hour); if hour < 0 { - hour += 24; + hour += Hour.per(Day) as i8; is_previous_day = true; } @@ -457,7 +471,7 @@ impl Time { /// ``` #[must_use = "This method does not mutate the original `Time`."] pub const fn replace_hour(self, hour: u8) -> Result { - ensure_value_in_range!(hour in 0 => 23); + ensure_value_in_range!(hour in 0 => Hour.per(Day) - 1); Ok(Self::__from_hms_nanos_unchecked( hour, self.minute, @@ -478,7 +492,7 @@ impl Time { /// ``` #[must_use = "This method does not mutate the original `Time`."] pub const fn replace_minute(self, minute: u8) -> Result { - ensure_value_in_range!(minute in 0 => 59); + ensure_value_in_range!(minute in 0 => Minute.per(Hour) - 1); Ok(Self::__from_hms_nanos_unchecked( self.hour, minute, @@ -499,7 +513,7 @@ impl Time { /// ``` #[must_use = "This method does not mutate the original `Time`."] pub const fn replace_second(self, second: u8) -> Result { - ensure_value_in_range!(second in 0 => 59); + ensure_value_in_range!(second in 0 => Second.per(Minute) - 1); Ok(Self::__from_hms_nanos_unchecked( self.hour, self.minute, @@ -523,12 +537,12 @@ impl Time { self, millisecond: u16, ) -> Result { - ensure_value_in_range!(millisecond in 0 => 999); + ensure_value_in_range!(millisecond in 0 => Millisecond.per(Second) - 1); Ok(Self::__from_hms_nanos_unchecked( self.hour, self.minute, self.second, - millisecond as u32 * 1_000_000, + millisecond as u32 * Nanosecond.per(Millisecond), )) } @@ -547,12 +561,12 @@ impl Time { self, microsecond: u32, ) -> Result { - ensure_value_in_range!(microsecond in 0 => 999_999); + ensure_value_in_range!(microsecond in 0 => Microsecond.per(Second) - 1); Ok(Self::__from_hms_nanos_unchecked( self.hour, self.minute, self.second, - microsecond * 1000, + microsecond * Nanosecond.per(Microsecond) as u32, )) } @@ -568,7 +582,7 @@ impl Time { /// ``` #[must_use = "This method does not mutate the original `Time`."] pub const fn replace_nanosecond(self, nanosecond: u32) -> Result { - ensure_value_in_range!(nanosecond in 0 => 999_999_999); + ensure_value_in_range!(nanosecond in 0 => Nanosecond.per(Second) - 1); Ok(Self::__from_hms_nanos_unchecked( self.hour, self.minute, @@ -745,12 +759,14 @@ impl Sub for Time { let second_diff = (self.second as i8) - (rhs.second as i8); let nanosecond_diff = (self.nanosecond as i32) - (rhs.nanosecond as i32); - let seconds = hour_diff as i64 * 3_600 + minute_diff as i64 * 60 + second_diff as i64; + let seconds = hour_diff as i64 * Second.per(Hour) as i64 + + minute_diff as i64 * Second.per(Minute) as i64 + + second_diff as i64; let (seconds, nanoseconds) = if seconds > 0 && nanosecond_diff < 0 { - (seconds - 1, nanosecond_diff + 1_000_000_000) + (seconds - 1, nanosecond_diff + Nanosecond.per(Second) as i32) } else if seconds < 0 && nanosecond_diff > 0 { - (seconds + 1, nanosecond_diff - 1_000_000_000) + (seconds + 1, nanosecond_diff - Nanosecond.per(Second) as i32) } else { (seconds, nanosecond_diff) }; -- cgit v1.2.3