reverse

Author: robertbastian

Cargo.lock

@@ -22,11 +22,12 @@ icu_time = { workspace = true }
 potential_utf = { workspace = true }
 resb = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
+calendrical_calculations = { workspace = true }
 
 chrono = { version = "0.4", optional = true }
 
 [dev-dependencies]
 chrono-tz = { git = "https://github.com/robertbastian/chrono-tz", branch = "fix" }
 
 [features]
-chrono = ["dep:chrono"]
+chrono = ["dep:chrono"]

utils/zoneinfo64/Cargo.toml

@@ -2,11 +2,14 @@
 // called LICENSE at the top level of the ICU4X source tree
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
-use crate::{Transition, Zone};
+use crate::{Offset, PossibleOffset, Zone};
+use chrono::{
+    Datelike, FixedOffset, MappedLocalTime, NaiveDate, NaiveDateTime, TimeZone, Timelike,
+};
 use icu_time::zone::UtcOffset;
 
 #[derive(Clone, Copy, Debug)]
-pub struct ChronoOffset<'a>(Transition, Zone<'a>);
+pub struct ChronoOffset<'a>(Offset, Zone<'a>);
 
 impl core::ops::Deref for ChronoOffset<'_> {
     type Target = UtcOffset;
@@ -22,43 +25,61 @@ impl ChronoOffset<'_> {
     }
 }
 
-#[cfg(feature = "chrono")]
 impl<'a> chrono::Offset for ChronoOffset<'a> {
-    fn fix(&self) -> chrono::FixedOffset {
-        chrono::FixedOffset::east_opt(self.0.offset.to_seconds()).unwrap()
+    fn fix(&self) -> FixedOffset {
+        FixedOffset::east_opt(self.0.offset.to_seconds()).unwrap()
     }
 }
 
-#[cfg(feature = "chrono")]
-impl<'a> chrono::TimeZone for Zone<'a> {
+impl<'a> TimeZone for Zone<'a> {
     type Offset = ChronoOffset<'a>;
 
     fn from_offset(offset: &Self::Offset) -> Self {
         offset.1
     }
 
-    fn offset_from_local_date(
-        &self,
-        _local: &chrono::NaiveDate,
-    ) -> chrono::MappedLocalTime<Self::Offset> {
-        todo!()
+    fn offset_from_local_date(&self, local: &NaiveDate) -> MappedLocalTime<Self::Offset> {
+        match self.for_date_time(
+            local.year(),
+            local.month() as u8,
+            local.day() as u8,
+            0,
+            0,
+            0,
+        ) {
+            PossibleOffset::None => chrono::MappedLocalTime::None,
+            PossibleOffset::Single(o) => chrono::MappedLocalTime::Single(ChronoOffset(o, *self)),
+            PossibleOffset::Ambiguous(a, b) => {
+                MappedLocalTime::Ambiguous(ChronoOffset(a, *self), ChronoOffset(b, *self))
+            }
+        }
     }
 
-    fn offset_from_local_datetime(
-        &self,
-        _local: &chrono::NaiveDateTime,
-    ) -> chrono::MappedLocalTime<Self::Offset> {
-        todo!()
+    fn offset_from_local_datetime(&self, local: &NaiveDateTime) -> MappedLocalTime<Self::Offset> {
+        match self.for_date_time(
+            local.year(),
+            local.month() as u8,
+            local.day() as u8,
+            local.hour() as u8,
+            local.minute() as u8,
+            local.second() as u8,
+        ) {
+            PossibleOffset::None => chrono::MappedLocalTime::None,
+            PossibleOffset::Single(o) => chrono::MappedLocalTime::Single(ChronoOffset(o, *self)),
+            PossibleOffset::Ambiguous(a, b) => {
+                MappedLocalTime::Ambiguous(ChronoOffset(a, *self), ChronoOffset(b, *self))
+            }
+        }
     }
 
-    fn offset_from_utc_date(&self, utc: &chrono::NaiveDate) -> Self::Offset {
+    fn offset_from_utc_date(&self, utc: &NaiveDate) -> Self::Offset {
         ChronoOffset(
-            self.previous_transition(utc.and_time(chrono::NaiveTime::MIN).and_utc().timestamp()),
+            self.for_timestamp(utc.and_time(chrono::NaiveTime::MIN).and_utc().timestamp()),
             *self,
         )
     }
 
-    fn offset_from_utc_datetime(&self, utc: &chrono::NaiveDateTime) -> Self::Offset {
-        ChronoOffset(self.previous_transition(utc.and_utc().timestamp()), *self)
+    fn offset_from_utc_datetime(&self, utc: &NaiveDateTime) -> Self::Offset {
+        ChronoOffset(self.for_timestamp(utc.and_utc().timestamp()), *self)
     }
 }