Add weekday, month and era getters on FixedCalendarDateTimeNames

Author: WaterWhisperer

components/datetime/src/pattern/names.rs

@@ -10,7 +10,7 @@ use super::{
 use crate::error::ErrorField;
 use crate::fieldsets::enums::{CompositeDateTimeFieldSet, CompositeFieldSet};
 use crate::provider::fields::{self, FieldLength, FieldSymbol};
-use crate::provider::neo::{marker_attrs, *};
+use crate::provider::neo::{get_year_name_from_map, marker_attrs, MonthNames, YearNames, *};
 use crate::provider::pattern::PatternItem;
 use crate::provider::time_zones::tz;
 use crate::size_test_macro::size_test;
@@ -19,7 +19,7 @@ use crate::{external_loaders::*, DateTimeFormatterPreferences};
 use crate::{scaffold::*, DateTimeFormatter, DateTimeFormatterLoadError};
 use core::fmt;
 use core::marker::PhantomData;
-use icu_calendar::types::{EraYear, MonthCode};
+use icu_calendar::types::{EraYear, MonthCode, Weekday};
 use icu_calendar::AnyCalendar;
 use icu_decimal::options::DecimalFormatterOptions;
 use icu_decimal::options::GroupingStrategy;
@@ -2826,6 +2826,200 @@ where
     }
 }
 
+impl<C, FSet: DateTimeNamesMarker> FixedCalendarDateTimeNames<C, FSet>
+where
+    FSet::WeekdayNames: NamesContainer<
+        WeekdayNamesV1,
+        WeekdayNameLength,
+        Container = DataPayloadWithVariables<WeekdayNamesV1, WeekdayNameLength>,
+    >,
+{
+    /// Gets the weekday name for the specified length and weekday if the data is loaded.
+    ///
+    /// Returns `Some` if the data for the specified length is loaded, or `None` if not loaded.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use icu::calendar::types::Weekday;
+    /// use icu::calendar::Gregorian;
+    /// use icu::datetime::pattern::{FixedCalendarDateTimeNames, WeekdayNameLength};
+    /// use icu::locale::locale;
+    ///
+    /// let mut names =
+    ///     FixedCalendarDateTimeNames::<Gregorian>::try_new(locale!("en").into())
+    ///         .unwrap();
+    ///
+    /// // Before loading data, the getter returns None:
+    /// assert_eq!(names.get_weekday(Weekday::Monday, WeekdayNameLength::Wide), None);
+    ///
+    /// // Load the weekday names:
+    /// names
+    ///     .include_weekday_names(WeekdayNameLength::Wide)
+    ///     .unwrap();
+    ///
+    /// // Now we can get the weekday name for the loaded length:
+    /// assert_eq!(
+    ///     names.get_weekday(Weekday::Monday, WeekdayNameLength::Wide),
+    ///     Some("Monday")
+    /// );
+    ///
+    /// // But other lengths are not loaded:
+    /// assert_eq!(
+    ///     names.get_weekday(Weekday::Monday, WeekdayNameLength::Abbreviated),
+    ///     None
+    /// );
+    /// ```
+    pub fn get_weekday(&self, weekday: Weekday, length: WeekdayNameLength) -> Option<&str> {
+        let borrowed = self.inner.as_borrowed();
+        borrowed
+            .weekday_names
+            .get_with_variables(length)
+            .and_then(|names| names.names.get((weekday as usize) % 7))
+    }
+}
+
+impl<C: CldrCalendar, FSet: DateTimeNamesMarker> FixedCalendarDateTimeNames<C, FSet>
+where
+    FSet::MonthNames: NamesContainer<
+        MonthNamesV1,
+        MonthNameLength,
+        Container = DataPayloadWithVariables<MonthNamesV1, MonthNameLength>,
+    >,
+{
+    /// Gets the month name for the specified length and month code if the data is loaded.
+    ///
+    /// Returns `Some` if the data for the specified length is loaded and the month code is valid,
+    /// or `None` if not loaded or the month code is invalid.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use icu::calendar::types::MonthCode;
+    /// use icu::calendar::Gregorian;
+    /// use icu::datetime::pattern::{FixedCalendarDateTimeNames, MonthNameLength};
+    /// use icu::locale::locale;
+    ///
+    /// let mut names =
+    ///     FixedCalendarDateTimeNames::<Gregorian>::try_new(locale!("en").into())
+    ///         .unwrap();
+    ///
+    /// // Before loading data, the getter returns None:
+    /// assert_eq!(
+    ///     names.get_month(MonthCode(tinystr::tinystr!(4, "M01")), MonthNameLength::Wide),
+    ///     None
+    /// );
+    ///
+    /// // Load the month names:
+    /// names
+    ///     .include_month_names(MonthNameLength::Wide)
+    ///     .unwrap();
+    ///
+    /// // Now we can get the month name for the loaded length:
+    /// assert_eq!(
+    ///     names.get_month(MonthCode(tinystr::tinystr!(4, "M01")), MonthNameLength::Wide),
+    ///     Some("January")
+    /// );
+    ///
+    /// // But other lengths are not loaded:
+    /// assert_eq!(
+    ///     names.get_month(
+    ///         MonthCode(tinystr::tinystr!(4, "M01")),
+    ///         MonthNameLength::Abbreviated
+    ///     ),
+    ///     None
+    /// );
+    /// ```
+    pub fn get_month(&self, month_code: MonthCode, length: MonthNameLength) -> Option<&str> {
+        let borrowed = self.inner.as_borrowed();
+        let month_names = borrowed.month_names.get_with_variables(length)?;
+
+        let (month_number, is_leap) = month_code.parsed()?;
+        let month_index = usize::from(month_number.checked_sub(1)?);
+
+        match month_names {
+            MonthNames::Linear(linear) => {
+                if is_leap {
+                    None
+                } else {
+                    linear.get(month_index)
+                }
+            }
+            MonthNames::LeapLinear(leap_linear) => {
+                let num_months = leap_linear.len() / 2;
+                if is_leap {
+                    leap_linear.get(month_index + num_months)
+                } else if month_index < num_months {
+                    leap_linear.get(month_index)
+                } else {
+                    None
+                }
+            }
+            MonthNames::LeapNumeric(_) => None,
+        }
+    }
+}
+
+impl<C: CldrCalendar, FSet: DateTimeNamesMarker> FixedCalendarDateTimeNames<C, FSet>
+where
+    FSet::YearNames: NamesContainer<
+        YearNamesV1,
+        YearNameLength,
+        Container = DataPayloadWithVariables<YearNamesV1, YearNameLength>,
+    >,
+{
+    /// Gets the era name for the specified length and era if the data is loaded.
+    ///
+    /// Returns `Some` if the data for the specified length is loaded and the era is valid,
+    /// or `None` if not loaded or the era is invalid.
+    ///
+    /// Note: This is a low-level API. The `era_year` parameter is typically obtained from
+    /// calendar date operations. Most users should use the formatting APIs instead.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use icu::calendar::{Date, Gregorian};
+    /// use icu::datetime::pattern::{FixedCalendarDateTimeNames, YearNameLength};
+    /// use icu::locale::locale;
+    ///
+    /// let mut names =
+    ///     FixedCalendarDateTimeNames::<Gregorian>::try_new(locale!("en").into())
+    ///         .unwrap();
+    ///
+    /// // Get era from a date
+    /// let date = Date::try_new_gregorian(2024, 1, 1).unwrap();
+    /// let era_year = date.era_year();
+    ///
+    /// // Before loading data, the getter returns None:
+    /// assert_eq!(names.get_era(&era_year, YearNameLength::Wide), None);
+    ///
+    /// // Load the year names:
+    /// names.include_year_names(YearNameLength::Wide).unwrap();
+    ///
+    /// // Now we can get the era name for the loaded length:
+    /// assert_eq!(names.get_era(&era_year, YearNameLength::Wide), Some("Anno Domini"));
+    ///
+    /// // But other lengths are not loaded:
+    /// assert_eq!(
+    ///     names.get_era(&era_year, YearNameLength::Abbreviated),
+    ///     None
+    /// );
+    /// ```
+    pub fn get_era(&self, era_year: &EraYear, length: YearNameLength) -> Option<&str> {
+        let borrowed = self.inner.as_borrowed();
+        let year_names = borrowed.year_names.get_with_variables(length)?;
+
+        match (year_names, era_year.era_index) {
+            (YearNames::VariableEras(era_names), None) => {
+                get_year_name_from_map(era_names, era_year.era.as_str().into())
+            }
+            (YearNames::FixedEras(era_names), Some(index)) => era_names.get(index as usize),
+            _ => None,
+        }
+    }
+}
+
 impl<FSet: DateTimeNamesMarker> DateTimeNames<FSet> {
     /// Maps a [`FixedCalendarDateTimeNames`] of a specific `FSet` to a more general `FSet`.
     ///