Enum SubsecondDigits

#[non_exhaustive]
pub enum SubsecondDigits {
    S1 = 1,
    S2 = 2,
    S3 = 3,
    S4 = 4,
    S5 = 5,
    S6 = 6,
    S7 = 7,
    S8 = 8,
    S9 = 9,
}

A specification for how many fractional second digits to display.

For example, to display the time with millisecond precision, use SubsecondDigits::S3.

Lower-precision digits will be truncated.

Examples

Times can be displayed with a custom number of fractional digits from 0-9:

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

let formatter = FixedCalendarDateTimeFormatter::<(), _>::try_new(
    locale!("en-US").into(),
    T::short()
        .with_time_precision(TimePrecision::Subsecond(SubsecondDigits::S2)),
)
.unwrap();

assert_writeable_eq!(
    formatter.format(&Time::try_new(16, 12, 20, 543200000).unwrap()),
    "4:12:20.54 PM"
);

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.

S1 = 1

One fractional digit (tenths of a second).

S2 = 2

Two fractional digits (hundredths of a second).

S3 = 3

Three fractional digits (milliseconds).

S4 = 4

Four fractional digits.

S5 = 5

Five fractional digits.

S6 = 6

Six fractional digits (microseconds).

S7 = 7

Seven fractional digits.

S8 = 8

Eight fractional digits.

S9 = 9

Nine fractional digits (nanoseconds)

Trait Implementations

impl Clone for SubsecondDigits

fn clone(&self) -> SubsecondDigits

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SubsecondDigits

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

Formats the value using the given formatter.

impl From<SubsecondDigits> for u8

fn from(value: SubsecondDigits) -> u8

Converts to this type from the input type.

impl Hash for SubsecondDigits

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

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 PartialEq for SubsecondDigits

fn eq(&self, other: &SubsecondDigits) -> 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 TryFrom<u8> for SubsecondDigits

type Error = SubsecondError

The type returned in the event of a conversion error.

fn try_from(value: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for SubsecondDigits

impl Eq for SubsecondDigits

impl StructuralPartialEq for SubsecondDigits