split japanese calendar implementations

Author: robertbastian

components/calendar/src/cal/japanese.rs

@@ -73,7 +73,9 @@ pub struct Japanese {
 /// These eras are loaded from data, requiring a data provider capable of providing [`CalendarJapaneseExtendedV1`]
 /// data.
 #[derive(Clone, Debug, Default)]
-pub struct JapaneseExtended(Japanese);
+pub struct JapaneseExtended {
+    eras: DataPayload<CalendarJapaneseExtendedV1>,
+}
 
 impl Japanese {
     /// Creates a new [`Japanese`] using only modern eras (post-meiji) from compiled data.
@@ -116,11 +118,11 @@ impl JapaneseExtended {
     /// [📚 Help choosing a constructor](icu_provider::constructors)
     #[cfg(feature = "compiled_data")]
     pub const fn new() -> Self {
-        Self(Japanese {
+        Self {
             eras: DataPayload::from_static_ref(
                 crate::provider::Baked::SINGLETON_CALENDAR_JAPANESE_EXTENDED_V1,
             ),
-        })
+        }
     }
 
     icu_provider::gen_buffer_data_constructors!(() -> error: DataError,
@@ -135,9 +137,9 @@ impl JapaneseExtended {
     pub fn try_new_unstable<D: DataProvider<CalendarJapaneseExtendedV1> + ?Sized>(
         provider: &D,
     ) -> Result<Self, DataError> {
-        Ok(Self(Japanese {
-            eras: provider.load(Default::default())?.payload.cast(),
-        }))
+        Ok(Self {
+            eras: provider.load(Default::default())?.payload,
+        })
     }
 }
 
@@ -273,30 +275,136 @@ impl GregorianYears for &'_ Japanese {
     }
 
     fn debug_name(&self) -> &'static str {
-        if self.eras.get().dates_to_eras.len() > 10 {
-            "Japanese (historical era data)"
-        } else {
-            "Japanese"
-        }
+        "Japanese"
     }
 
     fn calendar_algorithm(&self) -> Option<crate::preferences::CalendarAlgorithm> {
-        if self.eras.get().dates_to_eras.len() > 10 {
-            None
-        } else {
-            Some(crate::preferences::CalendarAlgorithm::Japanese)
-        }
+        Some(crate::preferences::CalendarAlgorithm::Japanese)
     }
 }
 
 impl_with_abstract_gregorian!(Japanese, JapaneseDateInner, Japanese, this, this);
 
+impl GregorianYears for &'_ JapaneseExtended {
+    fn extended_from_era_year(
+        &self,
+        era: Option<&[u8]>,
+        year: i32,
+    ) -> Result<i32, UnknownEraError> {
+        if let Ok(g) = CeBce.extended_from_era_year(era, year) {
+            return Ok(g);
+        }
+        let Some(era) = era else {
+            // unreachable, handled by CeBce
+            return Err(UnknownEraError);
+        };
+
+        // Avoid linear search by trying well known eras
+        if era == b"reiwa" {
+            return Ok(year - 1 + REIWA_START.year);
+        } else if era == b"heisei" {
+            return Ok(year - 1 + HEISEI_START.year);
+        } else if era == b"showa" {
+            return Ok(year - 1 + SHOWA_START.year);
+        } else if era == b"taisho" {
+            return Ok(year - 1 + TAISHO_START.year);
+        } else if era == b"meiji" {
+            return Ok(year - 1 + MEIJI_START.year);
+        }
+
+        let data = &self.eras.get().dates_to_eras;
+
+        // Try to avoid linear search by binary searching for the year suffix
+        if let Some(start_year) = era
+            .split(|x| *x == b'-')
+            .nth(1)
+            .and_then(|y| core::str::from_utf8(y).ok()?.parse::<i32>().ok())
+        {
+            if let Ok(index) = data.binary_search_by(|(d, _)| d.year.cmp(&start_year)) {
+                // There is a slight chance we hit the case where there are two eras in the same year
+                // There are a couple of rare cases of this, but it's not worth writing a range-based binary search
+                // to catch them since this is an optimization
+                #[expect(clippy::unwrap_used)] // binary search
+                if data.get(index).unwrap().1.as_bytes() == era {
+                    return Ok(start_year + year - 1);
+                }
+            }
+        }
+
+        // Avoidance didn't work. Let's find the era manually, searching back from the present
+        let era_start = data
+            .iter()
+            .rev()
+            .find_map(|(s, e)| (e.as_bytes() == era).then_some(s))
+            .ok_or(UnknownEraError)?;
+        Ok(era_start.year + year - 1)
+    }
+
+    fn era_year_from_extended(&self, year: i32, month: u8, day: u8) -> types::EraYear {
+        let date: EraStartDate = EraStartDate { year, month, day };
+
+        let (start, era) = if date >= MEIJI_START
+            && self
+                .eras
+                .get()
+                .dates_to_eras
+                .last()
+                .is_some_and(|(_, e)| e == tinystr!(16, "reiwa"))
+        {
+            // We optimize for the five "modern" post-Meiji eras, which are stored in a smaller
+            // array and also hardcoded. The hardcoded version is not used if data indicates the
+            // presence of newer eras.
+            if date >= REIWA_START {
+                (REIWA_START, tinystr!(16, "reiwa"))
+            } else if date >= HEISEI_START {
+                (HEISEI_START, tinystr!(16, "heisei"))
+            } else if date >= SHOWA_START {
+                (SHOWA_START, tinystr!(16, "showa"))
+            } else if date >= TAISHO_START {
+                (TAISHO_START, tinystr!(16, "taisho"))
+            } else {
+                (MEIJI_START, tinystr!(16, "meiji"))
+            }
+        } else {
+            let data = &self.eras.get().dates_to_eras;
+            #[allow(clippy::unwrap_used)] // binary search
+            match data.binary_search_by(|(d, _)| d.cmp(&date)) {
+                Err(0) => {
+                    return types::EraYear {
+                        // TODO: return era indices?
+                        era_index: None,
+                        ..CeBce.era_year_from_extended(year, month, day)
+                    };
+                }
+                Ok(index) => data.get(index).unwrap(),
+                Err(index) => data.get(index - 1).unwrap(),
+            }
+        };
+
+        types::EraYear {
+            era,
+            era_index: None,
+            year: year - start.year + 1,
+            extended_year: year,
+            ambiguity: types::YearAmbiguity::CenturyRequired,
+        }
+    }
+
+    fn debug_name(&self) -> &'static str {
+        "Japanese (historical era data)"
+    }
+
+    fn calendar_algorithm(&self) -> Option<crate::preferences::CalendarAlgorithm> {
+        None
+    }
+}
+
 impl_with_abstract_gregorian!(
     JapaneseExtended,
     JapaneseExtendedDateInner,
     Japanese,
     this,
-    &this.0
+    this
 );
 
 impl Date<Japanese> {
@@ -411,7 +519,7 @@ impl Date<JapaneseExtended> {
             year,
             month,
             day,
-            &AbstractGregorian(&japanext_calendar.as_calendar().0),
+            &AbstractGregorian(japanext_calendar.as_calendar()),
         )
         .map(ArithmeticDate::cast)
         .map(JapaneseExtendedDateInner)