Struct frequency_unit::Frequency

pub struct Frequency { /* private fields */ }

Implementations

impl Frequency

pub fn from_hz<T: NumCast>(val: T) -> Self

pub fn from_mhz<T: NumCast>(val: T) -> Self

pub fn to_hz<T: NumCast>(&self) -> T

pub fn to_mhz<T: NumCast>(&self) -> T

Trait Implementations

impl Add for Frequency

type Output = Frequency

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for Frequency

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Frequency

fn clone(&self) -> Frequency

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Frequency

fn default() -> Frequency

Returns the “default value” for a type.

impl Display for Frequency

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

Formats the value using the given formatter.

Examples

use byte_unit::{Byte, Unit};

let byte = Byte::from_u64_with_unit(1555, Unit::KB).unwrap();

assert_eq!("1555000", byte.to_string());

use byte_unit::{Byte, UnitType};

let byte_based_2 = Byte::from_u64(10240);
let byte_based_10 = Byte::from_u64(10000);

assert_eq!("10240", format!("{byte_based_2}"));
assert_eq!("10000", format!("{byte_based_10}"));

// with an exact unit
assert_eq!("10 KiB", format!("{byte_based_2:#}"));
assert_eq!("10 KB", format!("{byte_based_10:#}"));

// with an exact unit, no spaces between the value and the unit
assert_eq!("10KiB", format!("{byte_based_2:-#}"));
assert_eq!("10KB", format!("{byte_based_10:-#}"));

// with a width, left alignment
assert_eq!("10     KiB", format!("{byte_based_2:#10}"));
assert_eq!("10      KB", format!("{byte_based_10:#10}"));

// with a width, right alignment
assert_eq!("    10 KiB", format!("{byte_based_2:>#10}"));
assert_eq!("     10 KB", format!("{byte_based_10:>#10}"));

// with a width, right alignment, more spaces between the value and the unit
assert_eq!("    10 KiB", format!("{byte_based_2:>+#10}"));
assert_eq!("    10  KB", format!("{byte_based_10:>+#10}"));

use byte_unit::{Byte, UnitType};

let byte = Byte::from_u64(3211776);

assert_eq!("3211776", format!("{byte}"));

// with a unit, still precisely
assert_eq!("3136.5 KiB", format!("{byte:#}"));

// with a unit and a larger precision (default is 3), still precisely
assert_eq!("3.211776 MB", format!("{byte:#.6}"));

// with a unit and a smaller precision (default is 3), still precisely
assert_eq!("3211776 B", format!("{byte:#.0}"));

impl<N: NumCast> Div<N> for Frequency

type Output = Frequency

The resulting type after applying the / operator.

fn div(self, rhs: N) -> Self::Output

Performs the / operation.

impl Div for Frequency

type Output = f64

The resulting type after applying the / operator.

fn div(self, rhs: Frequency) -> Self::Output

Performs the / operation.

impl<N: NumCast> Mul<N> for Frequency

type Output = Frequency

The resulting type after applying the * operator.

fn mul(self, rhs: N) -> Self::Output

Performs the * operation.

impl PartialEq for Frequency

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Frequency

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

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

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

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

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

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

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

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

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 Sub for Frequency

type Output = Frequency

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for Frequency

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for Frequency