Enum icu::datetime::options::Alignment

#[non_exhaustive]
pub enum Alignment {
    Auto,
    Column,
}

The alignment context of the formatted string.

By default, datetimes are formatted for a variable-width context. You can give a hint that the strings will be displayed in a column-like context, which will coerce numerics to be padded with zeros.

Examples

use icu::calendar::Date;
use icu::calendar::Gregorian;
use icu::datetime::fieldsets::YMD;
use icu::datetime::options::Alignment;
use icu::datetime::FixedCalendarDateTimeFormatter;
use icu::locale::locale;
use writeable::assert_writeable_eq;

let plain_formatter =
    FixedCalendarDateTimeFormatter::<Gregorian, _>::try_new(
        locale!("en-US").into(),
        YMD::short(),
    )
    .unwrap();

let column_formatter =
    FixedCalendarDateTimeFormatter::<Gregorian, _>::try_new(
        locale!("en-US").into(),
        YMD::short().with_alignment(Alignment::Column),
    )
    .unwrap();

// By default, en-US does not pad the month and day with zeros.
assert_writeable_eq!(
    plain_formatter.format(&Date::try_new_gregorian(2025, 1, 1).unwrap()),
    "1/1/25"
);

// The column alignment option hints that they should be padded.
assert_writeable_eq!(
    column_formatter.format(&Date::try_new_gregorian(2025, 1, 1).unwrap()),
    "01/01/25"
);

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Auto

Align fields as the locale specifies them to be aligned.

This is the default option.

Column

Align fields as appropriate for a column layout. For example:

US Holiday	Date
Memorial Day	05/26/2025
Labor Day	09/01/2025
Veterans Day	11/11/2025

This option causes numeric fields to be padded when necessary. It does not impact whether a numeric or spelled-out field is chosen.

Trait Implementations

impl Clone for Alignment

fn clone(&self) -> Alignment

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Alignment

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Alignment

fn deserialize<__D>( __deserializer: __D, ) -> Result<Alignment, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Alignment

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoOption<Alignment> for Alignment

fn into_option(self) -> Option<Alignment>

Return self as an Option<T>

impl PartialEq for Alignment

fn eq(&self, other: &Alignment) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Alignment

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Alignment

impl Eq for Alignment

impl StructuralPartialEq for Alignment