Enum TimePrecision

#[non_exhaustive]
pub enum TimePrecision {
    Hour,
    Minute,
    Second,
    Subsecond(SubsecondDigits),
    MinuteOptional,
}

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

Fractional second digits can be displayed with a fixed precision. If you would like additional options for fractional second digit display, please leave a comment in https://github.com/unicode-org/icu4x/issues/6008.

Examples

Comparison of all time precision options:

use icu::datetime::input::Time;
use icu::datetime::fieldsets::T;
use icu::datetime::options::SubsecondDigits;
use icu::datetime::options::TimePrecision;
use icu::datetime::FixedCalendarDateTimeFormatter;
use icu::locale::locale;
use writeable::assert_writeable_eq;

let formatters = [
    TimePrecision::Hour,
    TimePrecision::Minute,
    TimePrecision::Second,
    TimePrecision::Subsecond(SubsecondDigits::S2),
    TimePrecision::MinuteOptional,
]
.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, 543_200_000).unwrap(),
];

let expected_value_table = [
    // 7:00:00, 7:00:10, 7:12:20.5432
    ["7 AM", "7 AM", "7 AM"],                            // Hour
    ["7:00 AM", "7:00 AM", "7:12 AM"],                   // Minute
    ["7:00:00 AM", "7:00:10 AM", "7:12:20 AM"],          // Second
    ["7:00:00.00 AM", "7:00:10.00 AM", "7:12:20.54 AM"], // Subsecond(F2)
    ["7 AM", "7 AM", "7:12 AM"],                         // MinuteOptional
];

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.

Hour

Display the hour. Hide all other time fields.

Examples:

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

Minute

Display the hour and minute. Hide the second.

Examples:

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

Second

Display the hour, minute, and second. Hide fractional seconds.

This is currently the default, but the default is subject to change.

Examples:

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

Subsecond(SubsecondDigits)

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

Examples with SubsecondDigits::S1:

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

MinuteOptional

Display the hour; display the minute if nonzero. Hide the second.

Examples:

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

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

fn default() -> TimePrecision

Returns the “default value” for a 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 Copy for TimePrecision

impl Eq for TimePrecision

impl StructuralPartialEq for TimePrecision