Struct Frequency

#[repr(transparent)]
pub struct Frequency(pub u64);

Represents a frequency

This struct is a wrapper around a u64 value representing the frequency in hertz. It provides methods to convert between different frequency units (Hz, kHz, MHz, GHz) and to parse frequency strings.

Units

• Hertz (Hz)
• Kilohertz (kHz)
• Megahertz (MHz)
• Gigahertz (GHz)

Note

When converting to a string or using display, the frequency is formatted with two decimal places. This is done to provide a consistent representation of the frequency. However, this may lead to precision loss when converting back to a number.

Examples

use parse_frequency::Frequency;

let freq = Frequency::from_hz(parse_frequency::GIGAHERTZ);
assert_eq!(freq.as_ghz(), 1);

let freq: Frequency = "2.5GHz".parse().unwrap();
assert_eq!(freq.as_hz(), 2_500_000_000);

let strfreq: String = freq.to_string();
assert_eq!(strfreq, "2.50 GHz");

println!("Frequency: {}", freq);

Tuple Fields

0: u64

Implementations

impl Frequency

pub fn as_chrono_duration(&self) -> Duration

Converts the frequency to a chrono::Duration.

Examples

use parse_frequency::Frequency;

let freq = Frequency::from_ghz(1);
let duration = freq.as_chrono_duration();
assert_eq!(duration.num_nanoseconds(), Some(1));

let freq = Frequency::from_mhz(1);
let duration = freq.as_chrono_duration();
assert_eq!(duration.num_nanoseconds(), Some(1_000));

impl Frequency

pub fn as_time_duration(&self) -> Duration

Converts the frequency to a time::Duration.

Examples

use parse_frequency::Frequency;

let freq = Frequency::from_ghz(1);
let duration = freq.as_time_duration();
assert_eq!(duration.whole_nanoseconds(), 1);

let freq = Frequency::from_mhz(1);
let duration = freq.as_time_duration();
assert_eq!(duration.whole_nanoseconds(), 1_000);

impl Frequency

pub const ZERO: Self

Equivalent to 0 Hz

assert_eq!(Frequency::ZERO, Frequency::from_hz(0));

pub const HERTZ: Self

Equivalent to 1 Hz

assert_eq!(Frequency::HERTZ, Frequency::from_hz(1));

pub const KILOHERTZ: Self

Equivalent to 1 kHz

assert_eq!(Frequency::KILOHERTZ, Frequency::from_khz(1));

pub const MEGAHERTZ: Self

Equivalent to 1 MHz

assert_eq!(Frequency::MEGAHERTZ, Frequency::from_mhz(1));

pub const GIGAHERTZ: Self

Equivalent to 1 GHz

assert_eq!(Frequency::GIGAHERTZ, Frequency::from_ghz(1));

pub fn from_hz(hz: u64) -> Self

pub fn from_khz(khz: u64) -> Self

pub fn from_mhz(mhz: u64) -> Self

pub fn from_ghz(ghz: u64) -> Self

pub fn as_hz(&self) -> u64

pub fn as_khz(&self) -> u64

pub fn as_mhz(&self) -> u64

pub fn as_ghz(&self) -> u64

pub fn as_duration(&self) -> Duration

Converts the frequency to a std::time::Duration.

Examples

use parse_frequency::Frequency;

let freq = Frequency::from_ghz(1);
let duration = freq.as_duration();
assert_eq!(duration.as_nanos(), 1);

Returns

A std::time::Duration representing the frequency.

Trait Implementations

impl Add for Frequency

type Output = Frequency

The resulting type after applying the + operator.

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

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

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

Formats the value using the given formatter.

impl Default for Frequency

fn default() -> Frequency

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Frequency

fn deserialize<D>( deserializer: D, ) -> Result<Frequency, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Frequency

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

Formats the value using the given formatter.

impl Div<u64> for Frequency

type Output = Frequency

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for Frequency

type Output = Frequency

The resulting type after applying the / operator.

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

Performs the / operation.

impl FromStr for Frequency

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self>

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

impl Hash for Frequency

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl JsonSchema for Frequency

fn schema_name() -> String

The name of the generated JSON Schema.

fn json_schema(_gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

impl Mul<u64> for Frequency

type Output = Frequency

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for Frequency

type Output = Frequency

The resulting type after applying the * operator.

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

Performs the * operation.

impl Num for Frequency

type FromStrRadixErr = ParseIntError

fn from_str_radix(s: &str, _radix: u32) -> Result<Self, Self::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

impl One for Frequency

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl Ord for Frequency

fn cmp(&self, other: &Frequency) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Frequency

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

fn partial_cmp(&self, other: &Frequency) -> 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 Rem for Frequency

type Output = Frequency

The resulting type after applying the % operator.

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

Performs the % operation.

impl Serialize for Frequency

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for Frequency

type Output = Frequency

The resulting type after applying the - operator.

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

Performs the - operation.

impl TryFrom<&str> for Frequency

type Error = Error

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self>

Performs the conversion.

impl TryFrom<String> for Frequency

type Error = Error

The type returned in the event of a conversion error.

fn try_from(s: String) -> Result<Self>

Performs the conversion.

impl TypedValueParser for Frequency

type Value = Frequency

Argument’s value type

fn parse_ref( &self, _cmd: &Command, _arg: Option<&Arg>, value: &OsStr, ) -> Result<Frequency, Error>

Parse the argument value

fn parse_ref_( &self, cmd: &Command, arg: Option<&Arg>, value: &OsStr, _source: ValueSource, ) -> Result<Self::Value, Error>

Parse the argument value

fn parse( &self, cmd: &Command, arg: Option<&Arg>, value: OsString, ) -> Result<Self::Value, Error>

Parse the argument value

fn parse_( &self, cmd: &Command, arg: Option<&Arg>, value: OsString, _source: ValueSource, ) -> Result<Self::Value, Error>

Parse the argument value

fn possible_values( &self, ) -> Option<Box<dyn Iterator<Item = PossibleValue> + '_>>

Reflect on enumerated value properties

fn map<T, F>(self, func: F) -> MapValueParser<Self, F>

where T: Send + Sync + Clone, F: Fn(Self::Value) -> T + Clone,

Adapt a TypedValueParser from one value to another

fn try_map<T, E, F>(self, func: F) -> TryMapValueParser<Self, F>

where F: Fn(Self::Value) -> Result<T, E> + Clone + Send + Sync + 'static, T: Send + Sync + Clone, E: Into<Box<dyn Error + Sync + Send>>,

Adapt a TypedValueParser from one value to another

impl Zero for Frequency

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Copy for Frequency

impl Eq for Frequency

impl Send for Frequency

impl StructuralPartialEq for Frequency

impl Sync for Frequency