Struct embedded_time::rate::units::BitsPerSecond

pub struct BitsPerSecond<T: TimeInt = u32>(pub T);

Bits/s

Trait Implementations

impl<T: TimeInt, Rhs: Rate> Add<Rhs> for BitsPerSecond<T> where
    T: TryFrom<Rhs::T>,
    Rhs: FixedPoint, 

type Output = Self

The resulting type after applying the + operator.

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

Returns the sum as the LHS type

Examples

assert_eq!((Hertz(1_u32) + Hertz(1_u32)), Hertz(2_u32));

Panics

The same reason the integer operation would panic. Namely, if the result overflows the type.

let _ = Hertz(u32::MAX) + Hertz(1_u32);

impl<T: Clone + TimeInt> Clone for BitsPerSecond<T>

fn clone(&self) -> BitsPerSecond<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy + TimeInt> Copy for BitsPerSecond<T>

impl<T: Debug + TimeInt> Debug for BitsPerSecond<T>

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

Formats the value using the given formatter.

impl<T: TimeInt> Display for BitsPerSecond<T>

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

Just forwards the underlying integer to core::fmt::Display::fmt()

assert_eq!(format!("{}", Hertz(123_u32)), "123");

impl<T: Eq + TimeInt> Eq for BitsPerSecond<T>

impl<T: TimeInt> From<BitsPerSecond<T>> for Generic<T>

fn from(rate: BitsPerSecond<T>) -> Self

Performs the conversion.

impl<T: Ord + TimeInt> Ord for BitsPerSecond<T>

fn cmp(&self, other: &BitsPerSecond<T>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<T: TimeInt, Rhs: Rate> PartialEq<Rhs> for BitsPerSecond<T> where
    T: TryFrom<Rhs::T>,
    Rhs: FixedPoint,
    Rhs::T: TryFrom<T>, 

fn eq(&self, rhs: &Rhs) -> bool

assert_eq!(Hertz(123_000_u32), Kilohertz(123_u32));
assert_ne!(Hertz(123_001_u32), Kilohertz(123_u32));

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: TimeInt, Rhs: Rate> PartialOrd<Rhs> for BitsPerSecond<T> where
    T: TryFrom<Rhs::T>,
    Rhs: FixedPoint,
    Rhs::T: TryFrom<T>, 

fn partial_cmp(&self, rhs: &Rhs) -> Option<Ordering>

assert!(Hertz(2_001_u32) > Kilohertz(2_u32));
assert!(Hertz(1_999_u32) < Kilohertz(2_u32));

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

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

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

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

impl<T: TimeInt> Rate for BitsPerSecond<T>

fn try_into_generic<DestInt: TimeInt>(
    self,
    scaling_factor: Fraction
) -> Result<Generic<DestInt>, ConversionError> where
    Self: FixedPoint,
    DestInt: TryFrom<Self::T>, 

Construct a Generic Rate from an named Rate

fn try_from_duration<Duration: Duration>(
    duration: Duration
) -> Result<Self, ConversionError> where
    Duration: FixedPoint,
    u32: TryFrom<Duration::T>,
    Self: FixedPoint,
    Self::T: TryFrom<Duration::T>, 

Attempt to construct the given rate type from the given duration type

impl<T: TimeInt, Rhs: Rate> Rem<Rhs> for BitsPerSecond<T> where
    T: TryFrom<Rhs::T>,
    Rhs: FixedPoint, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Rhs) -> Self::Output

Returns the remainder as the LHS type

assert_eq!(Hertz(2_037_u32) % Kilohertz(1_u32), Hertz(37_u32));

impl<T: TimeInt> StructuralEq for BitsPerSecond<T>

impl<T: TimeInt, Rhs: Rate> Sub<Rhs> for BitsPerSecond<T> where
    T: TryFrom<Rhs::T>,
    Rhs: FixedPoint, 

type Output = Self

The resulting type after applying the - operator.

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

Returns the difference as the LHS type

Examples

assert_eq!((Hertz(2u32) - Hertz(1_u32)),
    Hertz(1_u32));

Panics

The same reason the integer operation would panic. Namely, if the result overflows the type.

let _ = Hertz(0_u32) - Hertz(1_u32);

impl<SourceInt: TimeInt, DestInt: TimeInt> TryFrom<Generic<SourceInt>> for BitsPerSecond<DestInt> where
    DestInt: TryFrom<SourceInt>, 

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(generic_rate: Generic<SourceInt>) -> Result<Self, Self::Error>

Construct a named Rate from a Generic Rate

Examples

assert_eq!(
    Hertz::<u64>::try_from(Generic::new(2_000_u32, Fraction::new(1,1_000))),
    Ok(Hertz(2_u64))
);

assert_eq!(
    Generic::new(2_000_u64, Fraction::new(1,1_000)).try_into(),
    Ok(Hertz(2_u64))
);

Errors

Failure will only occur if the provided value does not fit in the selected destination type.

---

ConversionError::Overflow : The conversion of the scaling factor causes an overflow.

assert_eq!(Hertz::<u32>::try_from(Generic::new(u32::MAX, Fraction::new(10,1))),
    Err(ConversionError::Overflow));

---

ConversionError::ConversionFailure : The integer conversion to that of the destination type fails.

assert_eq!(Hertz::<u32>::try_from(Generic::new(u32::MAX as u64 + 1, Fraction::new(1,1))),
    Err(ConversionError::ConversionFailure));