Struct ConstantRateDuration 

pub struct ConstantRateDuration { /* private fields */ }

Represents the duration of a dataset which has been sampled at a constant rate.

Examples

Consider an audio file which consists of 8_394_223 samples per channel recorded with a 48kHz sampling frequency. We can see what the duration of this is by using the default implementation of std::fmt::Display for a ConstantRateDuration which outputs the duration in the form hh:mm:ss;samples.

use sampled_data_duration::ConstantRateDuration;

let crd = ConstantRateDuration::new(8_394_223, 48000);
assert_eq!(crd.to_string(), "00:02:54;42223");

Implementations

impl ConstantRateDuration

pub fn new(count: u64, rate: u64) -> ConstantRateDuration

Construct a new ConstantRateDuration, where count corresponds to the number of samples and rate is the sampling rate in Hertz.

pub fn as_secs(&self) -> u64

Returns the number of whole seconds contained by this ConstantRateDuration.

The returned value does not include the fractional part of the duration which can be obtained with subsec_secs.

Example

use sampled_data_duration::ConstantRateDuration;

let crd = ConstantRateDuration::new(48000 * 62 + 123, 48000);
assert_eq!(crd.to_string(), "00:01:02;123");
assert_eq!(crd.as_secs(), 62);

pub fn as_mins(&self) -> u64

Returns the number of whole minutes contained by this ConstantRateDuration.

The returned value does not include the fractional part of the duration, and can be a value greater than 59.

Example

use sampled_data_duration::ConstantRateDuration;

let crd = ConstantRateDuration::new(48000 * 60 * 91, 48000);
assert_eq!(crd.to_string(), "01:31:00;0");
assert_eq!(crd.as_mins(), 91);

pub fn as_hours(&self) -> u64

Returns the number of whole hours contained by this ConstantRateDuration.

The returned value does not include the fractional part of the duration, and can be a value greater than 23.

Example

use sampled_data_duration::ConstantRateDuration;

let crd = ConstantRateDuration::new(48000 * 60 * 60 * 48 + 12345, 48000);
assert_eq!(crd.to_string(), "48:00:00;12345");
assert_eq!(crd.as_hours(), 48);

pub fn as_days(&self) -> u64

Returns the number of whole days contained by this ConstantRateDuration.

The returned value does not include the fractional part of the duration, and can be a value greater than 6.

Example

use sampled_data_duration::ConstantRateDuration;

let crd = ConstantRateDuration::new(48000 * 60 * 60 * 48 + 12345, 48000);
assert_eq!(crd.to_string(), "48:00:00;12345");
assert_eq!(crd.as_days(), 2);

pub fn as_weeks(&self) -> u64

Returns the number of whole weeks contained by this ConstantRateDuration.

The returned value does not include the fractional part of the duration.

Example

use sampled_data_duration::ConstantRateDuration;

let crd = ConstantRateDuration::new(48000 * 60 * 60 * 24 * 21 + 12345, 48000);
assert_eq!(crd.to_string(), "504:00:00;12345");
assert_eq!(crd.as_weeks(), 3);

pub fn subsec_samples(&self) -> u64

Returns the number of samples in the sub-second part of this ConstantRateDuration.

The returned value will always be less than the sampling rate.

Example

use sampled_data_duration::ConstantRateDuration;

let crd = ConstantRateDuration::new(48000 + 12345, 48000);
assert_eq!(crd.to_string(), "00:00:01;12345");
assert_eq!(crd.subsec_samples(), 12345);

pub fn subsec_nanos(&self) -> u32

Returns the whole number of nanoseconds in the fractional part of this ConstantRateDuration.

The returned value will always be less than one second i.e. > 1_000_000_000 nanoseconds.

Example

use sampled_data_duration::ConstantRateDuration;

let crd = ConstantRateDuration::new(48000 + 24000, 48000);
assert_eq!(crd.to_string(), "00:00:01;24000");
assert_eq!(crd.subsec_nanos(), 500_000_000);

pub fn subsec_secs(&self) -> f64

Return the sub-second part of this duration in seconds.

This will return a value in the range 0.0 <= subsec_secs < 1.0.

Example

use sampled_data_duration::ConstantRateDuration;

let crd = ConstantRateDuration::new(48000 + 24000, 48000);
assert_eq!(crd.to_string(), "00:00:01;24000");
assert_eq!(crd.subsec_secs(), 0.5);

pub fn submin_secs(&self) -> u64

Returns the whole number of seconds left over when this duration is measured in minutes.

The returned value will always be 0 <= submin_secs <= 59.

Example

use sampled_data_duration::ConstantRateDuration;

let crd = ConstantRateDuration::new(48000 * 65 + 32000, 48000);
assert_eq!(crd.to_string(), "00:01:05;32000");
assert_eq!(crd.submin_secs(), 5);

pub fn subhour_mins(&self) -> u64

Returns the whole number of minutes left over when this duration is measured in hours.

The returned value will always be 0 <= subhour_mins <= 59.

Example

use sampled_data_duration::ConstantRateDuration;

let crd = ConstantRateDuration::new(48000 * 60 * 68, 48000);
assert_eq!(crd.to_string(), "01:08:00;0");
assert_eq!(crd.subhour_mins(), 8);

pub fn subday_hours(&self) -> u64

Returns the whole number of hours left over when this duration is measured in days.

The returned value will always be 0 <= subday_hours <= 23.

Example

use sampled_data_duration::ConstantRateDuration;

let crd = ConstantRateDuration::new(48000 * 60 * 60 * 25, 48000);
assert_eq!(crd.to_string(), "25:00:00;0");
assert_eq!(crd.subday_hours(), 1);

pub fn subweek_days(&self) -> u64

Returns the whole number of days left over when this duration is measured in weeks.

The returned value will always be 0 <= subweek_days <= 6.

Example

use sampled_data_duration::ConstantRateDuration;

let crd = ConstantRateDuration::new(48000 * 60 * 60 * 24 * 9, 48000);
assert_eq!(crd.to_string(), "216:00:00;0");
assert_eq!(crd.subweek_days(), 2);

pub fn to_duration(&self) -> Duration

Returns this ConstantRateDuration as a std::time::Duration.

Example

use sampled_data_duration::ConstantRateDuration;

let crd = ConstantRateDuration::new(48000 * 42, 48000);
assert_eq!(crd.to_string(), "00:00:42;0");
assert_eq!(crd.to_duration().as_secs_f64(), 42.0);

pub fn try_add( self, other: ConstantRateDuration, ) -> Result<ConstantRateDuration, MixedRateDuration>

Computes self + other returning Ok(ConstantRateDuration) if the sampling rates of self and other are the same, or Err(MixedRateDuration) if they are not.

If the sample count of the new duration exceeds the maximum capacity of a u64 then this method will panic with the error message "overflow when adding ConstantRateDurations".

Examples

use sampled_data_duration::*;

let a = ConstantRateDuration::new(48000, 48000);
let b = ConstantRateDuration::new(48000 * 2, 48000);

if let Ok(c) = a.try_add(b) {
  assert_eq!(c.as_secs(), 3);
} else {
  assert!(false);
}

Errors

Will return a Err(MixedRateDuration) if the provided ConstantRateDurations have incommensurate sampling rates.

pub fn try_add_assign( &mut self, crd: ConstantRateDuration, ) -> Result<(), MixedRateDuration>

Add-assigns crd to this ConstantRateDuration returning Ok(()) if the sampling rates of self and other are the same, or Err(MixedRateDuration) if they are not.

If the sample count of updated duration exceeds the maximum capacity of a u64 then this method will panic with the error message "overflow when add-assigning ConstantRateDurations".

Examples

use sampled_data_duration::*;

let mut a = ConstantRateDuration::new(48000, 48000);
let b = ConstantRateDuration::new(48000 * 2, 48000);

if let Ok(()) = a.try_add_assign(b) {
  assert_eq!(a.as_secs(), 3);
} else {
  assert!(false);
}

Errors

Will return a Err(MixedRateDuration) if the provided ConstantRateDurations have incommensurate sampling rates.

pub fn try_saturating_sub( self, other: ConstantRateDuration, ) -> Result<ConstantRateDuration, Error>

Computes self - other returning Ok(ConstantRateDuration) if the sampling rates of self and other are the same, or Err(()) if they are not.

If the sample count of the new duration would be less than 0 then then returned ConstantRateDuraiton will have 0 duration — this is a what is meant by saturating..

Examples

use sampled_data_duration::*;

let a = ConstantRateDuration::new(48001, 48000);
let b = ConstantRateDuration::new(48000, 48000);

assert_eq!(a.try_saturating_sub(b), Ok(ConstantRateDuration::new(1, 48000)));

let c = ConstantRateDuration::new(48001, 48000);
let d = ConstantRateDuration::new(48000, 48000);    
assert_eq!(d.try_saturating_sub(c), Ok(ConstantRateDuration::new(0, 48000)));

let e = ConstantRateDuration::new(96000, 96000);
let f = ConstantRateDuration::new(48000, 48000);
assert_eq!(e.try_saturating_sub(f), Err(Error::IncommensurateRates));

Errors

Will return an Error::IncommensurateRates if the provided ConstantRateDurations have incommensurate sampling rates.

pub fn try_saturating_sub_assign( &mut self, crd: ConstantRateDuration, ) -> Result<(), Error>

Sub-assigns crd from this ConstantRateDuration returning Ok(()) if the sampling rates of self and other are the same, or Err(()) if they are not.

If the sample count of updated duration would be negative then it “saturates” and becomes zero.

Examples

use sampled_data_duration::*;

let mut a = ConstantRateDuration::new(10, 48000);
let b = ConstantRateDuration::new(2, 48000);

if let Ok(()) = a.try_saturating_sub_assign(b) {
  assert_eq!(a.subsec_samples(), 8);
} else {
  assert!(false);
}

let mut c = ConstantRateDuration::new(1, 48000);
let d = ConstantRateDuration::new(5, 48000);

if let Ok(()) = c.try_saturating_sub_assign(d) {
  assert_eq!(c.subsec_samples(), 0);
} else {
  assert!(false);
}

let mut e = ConstantRateDuration::new(96000, 96000);
let f = ConstantRateDuration::new(48000, 48000);
assert!(e.try_saturating_sub(f).is_err());

Errors

Will return an Error::IncommensurateRates if the provided ConstantRateDurations have incommensurate sampling rates.

Trait Implementations

impl Add<ConstantRateDuration> for MixedRateDuration

fn add(self, crd: ConstantRateDuration) -> MixedRateDuration

Add a ConstantRateDuration to this MixedRateDuration returning a new MixedRateDuration.

type Output = MixedRateDuration

The resulting type after applying the + operator.

impl AddAssign<ConstantRateDuration> for MixedRateDuration

fn add_assign(&mut self, crd: ConstantRateDuration)

Add a ConstantRateDuration to this MixedRateDuration.

impl Clone for ConstantRateDuration

fn clone(&self) -> ConstantRateDuration

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConstantRateDuration

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

Formats the value using the given formatter.

impl Display for ConstantRateDuration

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

Display this ConstantRateDuration in the form hh:mm:ss;samples.

impl Div<u64> for ConstantRateDuration

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

Divide a ConstantRateDuration by a u64 returning a new ConstantRateDuration.

type Output = ConstantRateDuration

The resulting type after applying the / operator.

impl DivAssign<u64> for ConstantRateDuration

fn div_assign(&mut self, rhs: u64)

Divide-assign a ConstantRateDuration by a u64.

impl From<ConstantRateDuration> for MixedRateDuration

fn from(crd: ConstantRateDuration) -> Self

Construct a MixedRateDuration from a ConstantRateDuration.

impl Mul<u64> for ConstantRateDuration

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

Multiply a ConstantRateDuration by a u64 returning a new ConstantRateDuration.

type Output = ConstantRateDuration

The resulting type after applying the * operator.

impl MulAssign<u64> for ConstantRateDuration

fn mul_assign(&mut self, rhs: u64)

Multiply-assign a ConstantRateDuration by a u64.

impl PartialEq for ConstantRateDuration

fn eq(&self, other: &ConstantRateDuration) -> 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 Sub<ConstantRateDuration> for MixedRateDuration

fn sub(self, crd: ConstantRateDuration) -> MixedRateDuration

Perform a saturating subtraction of a ConstantRateDuration from this MixedRateDuration returning a new MixedRateDuration.

type Output = MixedRateDuration

The resulting type after applying the - operator.

impl SubAssign<ConstantRateDuration> for MixedRateDuration

fn sub_assign(&mut self, crd: ConstantRateDuration)

Perform a saturating subtraction of a ConstantRateDuration from this MixedRateDuration.

impl Copy for ConstantRateDuration

impl StructuralPartialEq for ConstantRateDuration