Struct DateTimeNames

pub struct DateTimeNames<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: DateTimeNamesMarker> DateTimeNames<FSet>

pub fn new_without_number_formatting( prefs: DateTimeFormatterPreferences, calendar: AnyCalendar, ) -> Self

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

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

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(YMDT::long().hm()).unwrap();

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

impl<FSet> DateTimeNames<FSet>

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

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

where Baked: AllAnyCalendarPatternDataMarkers<FSet>,

Loads a pattern for the given field set 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.

Examples

use icu::calendar::AnyCalendar;
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 names = DateTimeNames::new_without_number_formatting(
    locale!("es-MX").into(),
    AnyCalendar::try_new(locale!("es-MX").into()).unwrap(),
);

let field_set = T::long().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::midnight()), "12:00 a.m.");

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

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, Self)>

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: DateTimeNamesMarker> DateTimeNames<FSet>

pub fn cast_into_fset<FSet2: DateTimeNamesFrom<FSet>>( self, ) -> DateTimeNames<FSet2>

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: DateTimeNamesMarker> AsMut<FixedCalendarDateTimeNames<(), FSet>> for DateTimeNames<FSet>

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

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

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

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

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

impl<FSet: Clone + DateTimeNamesMarker> Clone for DateTimeNames<FSet>

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 + DateTimeNamesMarker> Debug for DateTimeNames<FSet>

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

Formats the value using the given formatter.