Trait HasRefUnit 

pub trait HasRefUnit:
    Quantity
    + Add<Self>
    + Sub<Self>
    + Div<Self>
where
    <Self as Quantity>::UnitType: LinearScaledUnit,
{
    const REF_UNIT: <Self as Quantity>::UnitType;

    // Provided methods
    fn unit_from_scale(amnt: AmountT) -> Option<Self::UnitType> { ... }
    fn equiv_amount(&self, unit: Self::UnitType) -> AmountT { ... }
    fn convert(&self, to_unit: Self::UnitType) -> Self { ... }
    fn convert_assign(&mut self, to_unit: Self::UnitType) { ... }
    fn eq(&self, other: &Self) -> bool { ... }
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> { ... }
    fn add(self, rhs: Self) -> Self { ... }
    fn add_assign(&mut self, rhs: Self) { ... }
    fn sub(self, rhs: Self) -> Self { ... }
    fn sub_assign(&mut self, rhs: Self) { ... }
    fn div(self, rhs: Self) -> AmountT { ... }
}

Trait for quantities having a reference unit

Required Associated Constants

const REF_UNIT: <Self as Quantity>::UnitType

Unit used as reference for scaling the units of Self::UnitType.

Provided Methods

fn unit_from_scale(amnt: AmountT) -> Option<Self::UnitType>

Returns Some(unit) where unit.scale() == amnt, or None if there is no such unit.

fn equiv_amount(&self, unit: Self::UnitType) -> AmountT

Returns factor so that factor * unit == self.

fn convert(&self, to_unit: Self::UnitType) -> Self

Returns qty where qty == self and qty.unit() is to_unit.

fn convert_assign(&mut self, to_unit: Self::UnitType)

Converts self to the equivalent to_unit.

fn eq(&self, other: &Self) -> bool

Returns true, if self and other have equivalent amounts, otherwise false.

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

Returns the partial order of selfs amount and others eqivalent amount in selfs unit.

fn add(self, rhs: Self) -> Self

Returns the sum of self and other

fn add_assign(&mut self, rhs: Self)

Adds the unit-equivalent amount of other to self in place.

fn sub(self, rhs: Self) -> Self

Returns the difference between self and other

fn sub_assign(&mut self, rhs: Self)

Subtracts the unit-equivalent amount of other from self in place.

fn div(self, rhs: Self) -> AmountT

Returns the quotient self / other

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl HasRefUnit for Acceleration

const REF_UNIT: AccelerationUnit = AccelerationUnit::MeterPerSecondSquared

impl HasRefUnit for Area

const REF_UNIT: AreaUnit = AreaUnit::SquareMeter

impl HasRefUnit for DataThroughput

const REF_UNIT: DataThroughputUnit = DataThroughputUnit::BytePerSecond

impl HasRefUnit for DataVolume

const REF_UNIT: DataVolumeUnit = DataVolumeUnit::Byte

impl HasRefUnit for Duration

const REF_UNIT: DurationUnit = DurationUnit::Second

impl HasRefUnit for Energy

const REF_UNIT: EnergyUnit = EnergyUnit::Joule

impl HasRefUnit for Force

const REF_UNIT: ForceUnit = ForceUnit::Newton

impl HasRefUnit for Frequency

const REF_UNIT: FrequencyUnit = FrequencyUnit::Hertz

impl HasRefUnit for Length

const REF_UNIT: LengthUnit = LengthUnit::Meter

impl HasRefUnit for Mass

const REF_UNIT: MassUnit = MassUnit::Kilogram

impl HasRefUnit for Power

const REF_UNIT: PowerUnit = PowerUnit::Watt

impl HasRefUnit for Speed

const REF_UNIT: SpeedUnit = SpeedUnit::MeterPerSecond

impl HasRefUnit for Volume

const REF_UNIT: VolumeUnit = VolumeUnit::CubicMeter

impl HasRefUnit for AmountT

const REF_UNIT: One = ONE