Enum Time 

#[non_exhaustive]
pub enum Time {
    Century,
    Decade,
    Year,
    Week,
    Day,
    Hour,
    Minute,
    Second,
    Decisecond,
    Centisecond,
    Millisecond,
    Microsecond,
    Nanosecond,
    Picosecond,
}

A unit of time.

The listed abbreviations are the abbreviations used to parse the unit with FromStr. The main abbreviation comes first, followed by any alternate abbreviations that can be used.

The conversions are listed in terms of the base unit. The base unit for Time is Time::Second.

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.

Century

100 years, each of 365.25 days.

• Abbreviation: cen

• 1 cen = 3.15576e9 s

Decade

10 years, each of 365.25 days.

• Abbreviation: dec

• 1 dec = 3.15576e8 s

Year

A year of 365.25 days. Decades and centuries are defined in terms of this unit.

• Abbreviation: yr

• 1 yr = 3.15576e7 s

Week

• Abbreviation: wk

• 1 wk = 604800.0 s

Day

• Abbreviation: day

• 1 day = 86400.0 s

Hour

• Abbreviation: hr

• 1 hr = 3600.0 s

Minute

• Abbreviation: min

• 1 min = 60.0 s

Second

• Abbreviation: s

• 1 s = 1.0 s

Decisecond

• Abbreviation: ds

• 1 ds = 0.1 s

Centisecond

• Abbreviation: cs

• 1 cs = 0.01 s

Millisecond

• Abbreviation: ms

• 1 ms = 0.001 s

Microsecond

• Abbreviation: µs, us

• 1 µs = 1e-6 s

Nanosecond

• Abbreviation: ns

• 1 ns = 1e-9 s

Picosecond

• Abbreviation: ps

• 1 ps = 1e-12 s

Implementations

impl Time

pub fn pow(&self, power: i8) -> Unit

Creates a Unit with this quantity type and specified power.

pub fn squared(&self) -> Unit

Creates a Unit with this quantity type and power 2.

pub fn cubed(&self) -> Unit

Creates a Unit with this quantity type and power 3.

Trait Implementations

impl Clone for Time

fn clone(&self) -> Time

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Convert for Time

const BASE: Self = Time::Second

The base unit of this unit.

fn conversion_factor(&self) -> f64

Returns the conversion factor from &self to Convert::BASE, i.e. the value to multiply a quantity in this unit by, in order to get a quantity in Convert::BASE. If the self unit is the same as this unit, then this function should return 1.0.

fn conversion_factor_to(&self, _: impl Into<Unit>) -> Option<f64>

Defines the conversion factor from Convert::BASE, to a base unit that Convert::BASE is derived from. Returns None if there is no conversion factor, meaning the two units are unrelated.

impl Debug for Time

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

Formats the value using the given formatter.

impl Display for Time

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

Formats the value using the given formatter.

impl From<Time> for Base

fn from(u: Time) -> Self

Converts to this type from the input type.

impl From<Time> for CompoundUnit

fn from(u: Time) -> Self

Converts to this type from the input type.

impl From<Time> for Unit

fn from(u: Time) -> Self

Converts to this type from the input type.

impl FromStr for Time

type Err = InvalidUnit

The associated error which can be returned from parsing.

fn from_str(value: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for Time

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

type Error = InvalidUnit

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Copy for Time

impl Eq for Time

impl StructuralPartialEq for Time