Struct SecondsSince 

#[repr(transparent)]
pub struct SecondsSince<S>
where
    S: TimeScale,
{
    pub value: Quantity<dyn Dimension<Th = Z0, I = Z0, Kind = dyn Kind, M = Z0, L = Z0, J = Z0, N = Z0, T = PInt<UInt<UTerm, B1>>>, dyn Units<f64, length = meter, luminous_intensity = candela, thermodynamic_temperature = kelvin, mass = kilogram, time = second, electric_current = ampere, amount_of_substance = mole>, f64>,
    /* private fields */
}

Seconds elapsed in the named time scale, measured from that scale’s epoch.

The wrapped Time is uom::si::f64::Time so unit arithmetic works naturally (e.g. SecondsSince<TAI>::new(1.0.hours())).

Fields

value: Quantity<dyn Dimension<Th = Z0, I = Z0, Kind = dyn Kind, M = Z0, L = Z0, J = Z0, N = Z0, T = PInt<UInt<UTerm, B1>>>, dyn Units<f64, length = meter, luminous_intensity = candela, thermodynamic_temperature = kelvin, mass = kilogram, time = second, electric_current = ampere, amount_of_substance = mole>, f64>

Seconds in scale S. Stored as a uom Time so dimensionally-safe multiplications (velocity × time → position) compose out of the box.

Implementations

impl<S> SecondsSince<S>

where S: TimeScale,

pub fn new( t: Quantity<dyn Dimension<Th = Z0, I = Z0, Kind = dyn Kind, M = Z0, L = Z0, J = Z0, N = Z0, T = PInt<UInt<UTerm, B1>>>, dyn Units<f64, length = meter, luminous_intensity = candela, thermodynamic_temperature = kelvin, mass = kilogram, time = second, electric_current = ampere, amount_of_substance = mole>, f64>, ) -> SecondsSince<S>

Construct from a uom Time.

pub fn from_seconds(s: f64) -> SecondsSince<S>

Construct from raw SI seconds.

pub fn as_seconds(self) -> f64

Raw SI seconds.

Trait Implementations

impl<S> Clone for SecondsSince<S>

where S: Clone + TimeScale,

fn clone(&self) -> SecondsSince<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Debug for SecondsSince<S>

where S: Debug + TimeScale,

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

Formats the value using the given formatter.

impl<S> PartialEq for SecondsSince<S>

where S: PartialEq + TimeScale,

fn eq(&self, other: &SecondsSince<S>) -> 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<S> PartialOrd for SecondsSince<S>

where S: PartialOrd + TimeScale,

fn partial_cmp(&self, other: &SecondsSince<S>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<S> Copy for SecondsSince<S>

where S: Copy + TimeScale,

impl<S> StructuralPartialEq for SecondsSince<S>

where S: TimeScale,