uefi-raw: impl TryFrom for OffsetDateTime to Time

Author: phip1611

uefi-raw/CHANGELOG.md

@@ -16,6 +16,7 @@
   `OffsetDateTime` from the [time crate](https://crates.io/crates/time).
   - `Time::to_offset_date_time`
   - `Time::to_offset_date_time_with_default_timezone`
+  - implemented `TryFrom` from `OffsetDateTime` for `Time`
 
 ## Changed
 - Switched `*const Self` to `*mut Self` in `SerialIoProtocol::set_attributes()`

uefi-raw/src/time.rs

@@ -72,6 +72,7 @@ impl error::Error for ToOffsetDateTimeError {
 ///
 /// - [`Time::to_offset_date_time`]
 /// - [`Time::to_offset_date_time_with_default_timezone`]
+/// - [`TryFrom`] from [`OffsetDateTime`] to [`Time`]
 ///
 /// [time](https://crates.io/crates/time)
 #[derive(Debug, Default, Copy, Clone, Eq)]
@@ -355,6 +356,44 @@ bitflags! {
     }
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum FromOffsetDateTimeError {
+    /// The year is not representable as `u16`.
+    InvalidYear(i32),
+    /// Time zone offsets with seconds are not representable.
+    OffsetWithSeconds(i8),
+}
+
+#[cfg(feature = "time")]
+impl TryFrom<OffsetDateTime> for Time {
+    type Error = FromOffsetDateTimeError;
+
+    fn try_from(value: OffsetDateTime) -> Result<Self, Self::Error> {
+        let this = Self {
+            year: u16::try_from(value.date().year())
+                .map_err(|_| Self::Error::InvalidYear(value.date().year()))?,
+            // No checks needed: underlying type has repr `u8`
+            month: value.date().month() as u8,
+            day: value.date().day(),
+            hour: value.time().hour(),
+            minute: value.time().minute(),
+            second: value.time().second(),
+            pad1: 0,
+            nanosecond: value.time().nanosecond(),
+            time_zone: {
+                let (h, m, s) = value.offset().as_hms();
+                if s != 0 {
+                    return Err(Self::Error::OffsetWithSeconds(s));
+                }
+                (h as i16 * 60) + (m as i16)
+            },
+            daylight: Daylight::NONE,
+            pad2: 0,
+        };
+        Ok(this)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     extern crate alloc;
@@ -388,9 +427,9 @@ mod tests {
 }
 
 #[cfg(all(test, feature = "time"))]
-mod time_crate_tests {
+mod to_offset_date_time_tests {
     use super::*;
-    use time::{Date, Month, OffsetDateTime, Time as TimeOfDay, UtcOffset};
+    use time::{Date, Month, OffsetDateTime, UtcOffset};
 
     /// A valid base time for testing
     fn valid_base_time() -> Time {
@@ -416,7 +455,7 @@ mod time_crate_tests {
 
         let expected = OffsetDateTime::new_in_offset(
             Date::from_calendar_date(2024, Month::March, 15).unwrap(),
-            TimeOfDay::from_hms_nano(12, 34, 56, 123_456_789).unwrap(),
+            time::Time::from_hms_nano(12, 34, 56, 123_456_789).unwrap(),
             UtcOffset::UTC,
         );
 
@@ -432,7 +471,7 @@ mod time_crate_tests {
 
         let expected = OffsetDateTime::new_in_offset(
             Date::from_calendar_date(2024, Month::March, 15).unwrap(),
-            TimeOfDay::from_hms_nano(12, 34, 56, 123_456_789).unwrap(),
+            time::Time::from_hms_nano(12, 34, 56, 123_456_789).unwrap(),
             offset,
         );
 
@@ -603,3 +642,105 @@ mod time_crate_tests {
         assert_eq!(odt.offset(), offset);
     }
 }
+
+#[cfg(all(test, feature = "time"))]
+mod from_offset_datetime_tests {
+    use super::*;
+    use time::{Date, Month, OffsetDateTime, Time as TimeOfDay, UtcOffset};
+
+    #[test]
+    fn test_normal_conversion_utc() {
+        let odt = OffsetDateTime::new_in_offset(
+            Date::from_calendar_date(2024, Month::March, 15).unwrap(),
+            TimeOfDay::from_hms_nano(12, 34, 56, 123_456_789).unwrap(),
+            UtcOffset::UTC,
+        );
+
+        let t = Time::try_from(odt).unwrap();
+        assert_eq!(t.year, 2024);
+        assert_eq!(t.month, 3);
+        assert_eq!(t.day, 15);
+        assert_eq!(t.hour, 12);
+        assert_eq!(t.minute, 34);
+        assert_eq!(t.second, 56);
+        assert_eq!(t.nanosecond, 123_456_789);
+        assert_eq!(t.time_zone, 0);
+    }
+
+    #[test]
+    fn test_conversion_positive_offset() {
+        let offset = UtcOffset::from_hms(1, 30, 0).unwrap(); // +1:30
+        let odt = OffsetDateTime::new_in_offset(
+            Date::from_calendar_date(2024, Month::March, 15).unwrap(),
+            TimeOfDay::from_hms(8, 0, 0).unwrap(),
+            offset,
+        );
+
+        let t = Time::try_from(odt).unwrap();
+        assert_eq!(t.time_zone, 90); // 1*60 + 30
+    }
+
+    #[test]
+    fn test_conversion_negative_offset() {
+        let offset = UtcOffset::from_hms(-2, -15, 0).unwrap(); // -2:15
+        let odt = OffsetDateTime::new_in_offset(
+            Date::from_calendar_date(2024, Month::March, 15).unwrap(),
+            TimeOfDay::from_hms(20, 0, 0).unwrap(),
+            offset,
+        );
+
+        let t = Time::try_from(odt).unwrap();
+        assert_eq!(t.time_zone, -135); // -2*60 + -15
+    }
+
+    #[test]
+    fn test_offset_with_seconds_should_fail() {
+        let offset = UtcOffset::from_hms(0, 0, 1).unwrap(); // +0:0:1
+        let odt = OffsetDateTime::new_in_offset(
+            Date::from_calendar_date(2024, Month::March, 15).unwrap(),
+            TimeOfDay::from_hms(12, 0, 0).unwrap(),
+            offset,
+        );
+
+        let err = Time::try_from(odt).unwrap_err();
+        assert!(matches!(err, FromOffsetDateTimeError::OffsetWithSeconds(1)));
+    }
+
+    #[test]
+    fn test_invalid_year_negative() {
+        let odt = OffsetDateTime::new_in_offset(
+            Date::from_calendar_date(-1, Month::January, 1).unwrap(),
+            TimeOfDay::from_hms(0, 0, 0).unwrap(),
+            UtcOffset::UTC,
+        );
+
+        let err = Time::try_from(odt).unwrap_err();
+        assert!(matches!(err, FromOffsetDateTimeError::InvalidYear(-1)));
+    }
+
+    #[test]
+    fn test_maximum_supported_year() {
+        let odt = OffsetDateTime::new_in_offset(
+            Date::from_calendar_date(9999, Month::December, 31).unwrap(),
+            TimeOfDay::from_hms(23, 59, 59).unwrap(),
+            UtcOffset::UTC,
+        );
+
+        let t = Time::try_from(odt).unwrap();
+        assert_eq!(t.year, 9999);
+        assert_eq!(t.month, 12);
+        assert_eq!(t.day, 31);
+    }
+
+    #[test]
+    fn test_nanosecond_boundary() {
+        let odt = OffsetDateTime::new_in_offset(
+            Date::from_calendar_date(2024, Month::March, 15).unwrap(),
+            TimeOfDay::from_hms_nano(12, 0, 0, 999_999_999).unwrap(),
+            UtcOffset::UTC,
+        );
+
+        let t = Time::try_from(odt).unwrap();
+        assert_eq!(t.nanosecond, 999_999_999);
+    }
+}