Enum icu::datetime::options::TimePrecision

#[non_exhaustive]
pub enum TimePrecision {
    HourPlus,
    HourExact,
    MinutePlus,
    MinuteExact,
    SecondPlus,
    SecondExact(FractionalSecondDigits),
}

A specification for how precisely to display the time of day.

The time can be displayed with hour, minute, or second precision, and zero-valued fields can be automatically hidden.

The examples in the discriminants are based on the following inputs and hour cycles:

1. 11 o’clock with 12-hour time
2. 16:20 (4:20 pm) with 24-hour time
3. 7:15:01.85 with 24-hour time

Examples

use icu::calendar::Time;
use icu::datetime::fieldsets::T;
use icu::datetime::options::FractionalSecondDigits;
use icu::datetime::options::TimePrecision;
use icu::datetime::FixedCalendarDateTimeFormatter;
use icu::locale::locale;
use writeable::assert_writeable_eq;

let formatters = [
    TimePrecision::HourPlus,
    TimePrecision::HourExact,
    TimePrecision::MinutePlus,
    TimePrecision::MinuteExact,
    TimePrecision::SecondPlus,
    TimePrecision::SecondExact(FractionalSecondDigits::F0),
]
.map(|time_precision| {
    FixedCalendarDateTimeFormatter::<(), _>::try_new(
        locale!("en-US").into(),
        T::short().with_time_precision(time_precision),
    )
    .unwrap()
});

let times = [
    Time::try_new(7, 0, 0, 0).unwrap(),
    Time::try_new(7, 0, 10, 0).unwrap(),
    Time::try_new(7, 12, 20, 5).unwrap(),
];

// TODO(#5782): the Plus variants should render fractional digits
let expected_value_table = [
    // 7:00:00, 7:00:10, 7:12:20.5432
    ["7 AM", "7:00:10 AM", "7:12:20 AM"], // HourPlus
    ["7 AM", "7 AM", "7 AM"],             // HourExact
    ["7:00 AM", "7:00:10 AM", "7:12:20 AM"], // MinutePlus
    ["7:00 AM", "7:00 AM", "7:12 AM"],    // MinuteExact
    ["7:00:00 AM", "7:00:10 AM", "7:12:20 AM"], // SecondPlus
    ["7:00:00 AM", "7:00:10 AM", "7:12:20 AM"], // SecondExact
];

for (expected_value_row, formatter) in
    expected_value_table.iter().zip(formatters.iter())
{
    for (expected_value, time) in
        expected_value_row.iter().zip(times.iter())
    {
        assert_writeable_eq!(
            formatter.format(time),
            *expected_value,
            "{formatter:?} @ {time:?}"
        );
    }
}

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.

HourPlus

Always display the hour. Display smaller fields if they are nonzero.

Examples:

1. 11 am
2. 16:20
3. 07:15:01.85

HourExact

Always display the hour. Hide all other time fields.

Examples:

1. 11 am
2. 16h
3. 07h

MinutePlus

Always display the hour and minute. Display the second if nonzero.

Examples:

1. 11:00 am
2. 16:20
3. 07:15:01.85

MinuteExact

Always display the hour and minute. Hide the second.

Examples:

1. 11:00 am
2. 16:20
3. 07:15

SecondPlus

Display the hour, minute, and second. Display fractional seconds if nonzero.

This is the default.

Examples:

1. 11:00:00 am
2. 16:20:00
3. 07:15:01.85

SecondExact(FractionalSecondDigits)

Display the hour, minute, and second with the given number of fractional second digits.

Examples with FractionalSecondDigits::F1:

1. 11:00:00.0 am
2. 16:20:00.0
3. 07:15:01.8

Trait Implementations

impl Clone for TimePrecision

fn clone(&self) -> TimePrecision

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TimePrecision

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TimePrecision

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<TimePrecisionSerde> for TimePrecision

fn from(value: TimePrecisionSerde) -> TimePrecision

Converts to this type from the input type.

impl Hash for TimePrecision

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<TimePrecision> for TimePrecision

fn into_option(self) -> Option<TimePrecision>

Return self as an Option<T>

impl PartialEq for TimePrecision

fn eq(&self, other: &TimePrecision) -> 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 TimePrecision

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 TimePrecision

impl Eq for TimePrecision

impl StructuralPartialEq for TimePrecision