Struct DateTimeNames

pub struct DateTimeNames<FSet>
where
    FSet: DateTimeNamesMarker,
{ /* private fields */ }

A low-level type that formats datetime patterns with localized names. The calendar is chosen in the constructor at runtime.

Currently this only supports loading of non-calendar-specific names, but additional functions may be added in the future. If you need this, see https://github.com/unicode-org/icu4x/issues/6107

Implementations

impl<FSet> DateTimeNames<FSet>

where FSet: DateTimeNamesMarker,

pub fn try_new_with_calendar_without_number_formatting( prefs: DateTimeFormatterPreferences, calendar: AnyCalendar, ) -> Result<DateTimeNames<FSet>, UnsupportedCalendarError>

Creates a completely empty instance, not even with number formatting, with the specified calendar.

pub fn from_formatter( prefs: DateTimeFormatterPreferences, formatter: DateTimeFormatter<FSet>, ) -> DateTimeNames<FSet>

Creates an instance with the names and calendar loaded in a DateTimeFormatter.

This function requires passing in the DateTimeFormatterPreferences because it is not retained in the formatter. Pass the same value or else unexpected behavior may occur.

Examples

use icu::datetime::input::Date;
use icu::datetime::input::{DateTime, Time};
use icu::datetime::DateTimeFormatter;
use icu::datetime::fieldsets::{YMD, YMDT};
use icu::datetime::pattern::{DateTimeNames, DayPeriodNameLength};
use icu::locale::locale;
use writeable::assert_writeable_eq;

let prefs = locale!("es-MX").into();

let formatter =
    DateTimeFormatter::try_new(
        prefs,
        YMD::long(),
    )
    .unwrap();

assert_writeable_eq!(
    formatter.format(&Date::try_new_iso(2025, 2, 13).unwrap()),
    "13 de febrero de 2025"
);

// Change the YMD formatter to a YMDT formatter, after loading day period names.
// This assumes that the locale uses Abbreviated names for the given semantic skeleton!
let mut names = DateTimeNames::from_formatter(prefs, formatter).cast_into_fset::<YMDT>();
names.as_mut().include_day_period_names(DayPeriodNameLength::Abbreviated).unwrap();
let formatter = names.try_into_formatter(YMD::long().with_time_hm()).unwrap();

assert_writeable_eq!(
    formatter.format(&DateTime {
        date: Date::try_new_iso(2025, 2, 13).unwrap(),
        time: Time::start_of_day(),
    }),
    "13 de febrero de 2025, 12:00 a.m."
);

impl<FSet> DateTimeNames<FSet>

where FSet: DateTimeMarkers + GetField<CompositeFieldSet>, <FSet as DateTimeMarkers>::D: DateDataMarkers, <FSet as DateTimeMarkers>::T: TimeMarkers, <FSet as DateTimeMarkers>::Z: ZoneMarkers,

pub fn try_into_formatter( self, field_set: FSet, ) -> Result<DateTimeFormatter<FSet>, (DateTimeFormatterLoadError, DateTimeNames<FSet>)>

where Baked: AllAnyCalendarPatternDataMarkers<FSet>,

Loads a pattern for the given field set with compiled data and returns a DateTimeFormatter.

The names in the current DateTimeNames must be sufficient for the field set. If not, the input object will be returned with an error.

✨ Enabled with the compiled_data Cargo feature.

📚 Help choosing a constructor

Examples

use icu::calendar::{AnyCalendar, AnyCalendarKind};
use icu::datetime::fieldsets::T;
use icu::datetime::input::Time;
use icu::datetime::pattern::{DateTimeNames, DayPeriodNameLength};
use icu::locale::locale;
use writeable::assert_writeable_eq;

let kind = AnyCalendarKind::new(locale!("es-MX").into());
let calendar = AnyCalendar::new(kind);

let names = DateTimeNames::try_new_with_calendar_without_number_formatting(
    locale!("es-MX").into(),
    calendar,
)
.expect("All locale-default calendars are supported");

let field_set = T::hm();

// Cannot convert yet: no names are loaded
let mut names = names.try_into_formatter(field_set).unwrap_err().1;

// Load the data we need:
names
    .as_mut()
    .include_day_period_names(DayPeriodNameLength::Abbreviated)
    .unwrap();
names.as_mut().include_decimal_formatter().unwrap();

// Now the conversion is successful:
let formatter = names.try_into_formatter(field_set).unwrap();

assert_writeable_eq!(formatter.format(&Time::start_of_day()), "12:00 a.m.");

pub fn try_into_formatter_unstable<P>( self, provider: &P, field_set: FSet, ) -> Result<DateTimeFormatter<FSet>, (DateTimeFormatterLoadError, DateTimeNames<FSet>)>

where P: AllAnyCalendarPatternDataMarkers<FSet> + ?Sized,

A version of Self::try_into_formatter that uses custom data provided by a DataProvider.

📚 Help choosing a constructor

⚠️ The bounds on provider may change over time, including in SemVer minor releases.

pub fn try_into_formatter_with_buffer_provider<P>( self, provider: &P, field_set: FSet, ) -> Result<DateTimeFormatter<FSet>, (DateTimeFormatterLoadError, DateTimeNames<FSet>)>

where P: BufferProvider + ?Sized,

A version of Self::try_into_formatter that uses custom data provided by a BufferProvider.

✨ Enabled with the serde feature.

📚 Help choosing a constructor

impl<FSet> DateTimeNames<FSet>

where FSet: DateTimeNamesMarker,

pub fn cast_into_fset<FSet2>(self) -> DateTimeNames<FSet2>

where FSet2: DateTimeNamesFrom<FSet>,

Maps a FixedCalendarDateTimeNames of a specific FSet to a more general FSet.

For example, this can transform a formatter for DateFieldSet to one for CompositeDateTimeFieldSet.

Trait Implementations

impl<FSet> AsMut<FixedCalendarDateTimeNames<(), FSet>> for DateTimeNames<FSet>

where FSet: DateTimeNamesMarker,

fn as_mut(&mut self) -> &mut FixedCalendarDateTimeNames<(), FSet>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<FSet> AsRef<FixedCalendarDateTimeNames<(), FSet>> for DateTimeNames<FSet>

where FSet: DateTimeNamesMarker,

fn as_ref(&self) -> &FixedCalendarDateTimeNames<(), FSet>

Converts this type into a shared reference of the (usually inferred) input type.

impl<FSet> Clone for DateTimeNames<FSet>

where FSet: Clone + DateTimeNamesMarker,

fn clone(&self) -> DateTimeNames<FSet>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<FSet> Debug for DateTimeNames<FSet>

where FSet: Debug + DateTimeNamesMarker,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.