Struct MicroSeconds

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

Microseconds. Represents a span of time like std::time::Duration.

This is an unsigned 64-bit type, and thus represents absolute values only.

Tuple Fields

0: u64

Implementations

impl MicroSeconds

pub const INVALID: Self

MicroSeconds value representing an ‘invalid’ time.

Examples

assert_eq!(MicroSeconds::INVALID, MicroSeconds(std::u64::MAX));

pub const SECOND: Self

One second in microseconds.

Examples

assert_eq!(MicroSeconds::SECOND, MicroSeconds(1_000_000));

pub const MILLISECOND: Self

One millisecond in microseconds.

Examples

assert_eq!(MicroSeconds::MILLISECOND, MicroSeconds(1_000));

pub const ZERO: Self

Zero value.

Examples

assert_eq!(MicroSeconds::ZERO, MicroSeconds(0));

pub const MIN: Self

Smallest valid time value (zero).

Examples

assert_eq!(MicroSeconds::MIN, MicroSeconds(0));

pub const MAX: Self

Largest valid time value (largest integer value is reserved for representing ‘invalid’).

Roughly equal to 5,124,095,576 hours, 213,503,982 days, or 584,542 years.

Examples

assert_eq!(MicroSeconds::MAX, MicroSeconds(std::u64::MAX - 1));

pub const fn inner(&self) -> u64

Get the inner u64 value.

Examples

assert_eq!(MicroSeconds(100).inner(), 100);

pub const fn is_valid(&self) -> bool

Returns true so long as inner value is not Self::INVALID.

Examples

assert_eq!(MicroSeconds::MIN.is_valid(), true);
assert_eq!(MicroSeconds::MAX.is_valid(), true);
assert_eq!(MicroSeconds::INVALID.is_valid(), false);
assert_eq!(MicroSeconds::ZERO.is_valid(), true);
assert_eq!(MicroSeconds(60 * MICROS_PER_SEC).is_valid(), true);

pub const fn is_zero(&self) -> bool

Returns true so long as inner value is zero.

Examples

assert_eq!(MicroSeconds::ZERO.is_zero(), true);
assert_eq!(MicroSeconds(0).is_zero(), true);
assert_eq!(MicroSeconds(1).is_zero(), false);

pub fn from_secs(secs: u64) -> Option<Self>

Creates a new MicroSeconds from the specified number of whole seconds. Returns None on overflow.

Examples

assert_eq!(MicroSeconds::from_secs(2), Some(MicroSeconds(2_000_000)));
assert_eq!(MicroSeconds::from_secs(0xffff_ffff_0000_0000), None);

pub fn from_millis(millis: u64) -> Option<Self>

Creates a new MicroSeconds from the specified number of whole milliseconds. Returns None on overflow.

Examples

assert_eq!(MicroSeconds::from_millis(23), Some(MicroSeconds(23_000)));
assert_eq!(MicroSeconds::from_millis(0xffff_ffff_0000_0000), None);

pub fn diff(self, other: Self) -> Self

Returns the absolute difference with other.

Examples

assert_eq!(MicroSeconds(0).diff(MicroSeconds(0)), MicroSeconds(0));
assert_eq!(MicroSeconds(100).diff(MicroSeconds(100)), MicroSeconds(0));
assert_eq!(MicroSeconds(200).diff(MicroSeconds(150)), MicroSeconds(50));
assert_eq!(MicroSeconds(150).diff(MicroSeconds(200)), MicroSeconds(50));

pub const fn as_secs(&self) -> u64

Returns the total number of whole seconds.

Examples

assert_eq!(MicroSeconds(2_300_000).as_secs(), 2);
assert_eq!(MicroSeconds(2_800_000).as_secs(), 2);

pub const fn as_millis(&self) -> u64

Returns the total number of whole milliseconds.

Examples

assert_eq!(MicroSeconds(23_000_300).as_millis(), 23_000);
assert_eq!(MicroSeconds(23_000_800).as_millis(), 23_000);

pub fn from_secs_f64(secs: f64) -> Self

Creates a new MicroSeconds from the specified number of seconds represented as f64.

Panics if secs is not finite, is negative, or the value overflows.

Examples

assert_eq!(MicroSeconds::from_secs_f64(0.5), MicroSeconds(500_000));
assert_eq!(MicroSeconds::from_secs_f64(2.3), MicroSeconds(2_300_000));

These should panic.

MicroSeconds::from_secs_f64(std::f64::INFINITY);

MicroSeconds::from_secs_f64(-0.5);

MicroSeconds::from_secs_f64(std::f64::MAX);

MicroSeconds::from_secs_f64(std::f64::NAN);

pub fn from_secs_f32(secs: f32) -> Self

Creates a new MicroSeconds from the specified number of seconds represented as f32.

Panics if secs is not finite, is negative, or the value overflows.

Examples

assert_eq!(MicroSeconds::from_secs_f32(0.5), MicroSeconds(500_000));
assert_eq!(MicroSeconds::from_secs_f32(2.3), MicroSeconds(2_299_999));

These should panic.

MicroSeconds::from_secs_f32(std::f32::INFINITY);

MicroSeconds::from_secs_f32(-0.5);

MicroSeconds::from_secs_f32(std::f32::MAX);

MicroSeconds::from_secs_f32(std::f32::NAN);

pub fn as_secs_f64(&self) -> f64

Returns the number of seconds as f64.

Examples

assert_eq!(MicroSeconds(2_300_000).as_secs_f64(), 2.3);
assert_eq!(MicroSeconds(500_000).as_secs_f64(), 0.5);

pub fn as_secs_f32(&self) -> f32

Returns the number of seconds as f32.

Examples

assert_eq!(MicroSeconds(2_300_000).as_secs_f32(), 2.3);
assert_eq!(MicroSeconds(500_000).as_secs_f32(), 0.5);

pub fn checked_add(self, other: Self) -> Option<Self>

Checked integer addition. Computes self + rhs, returning None if overflow occurred, using the inner integer’s checked_add() method.

Examples

let quater_minute = MicroSeconds(15 * MICROS_PER_SEC);
let half_minute = MicroSeconds(30 * MICROS_PER_SEC);
let three_quater_minute = MicroSeconds(45 * MICROS_PER_SEC);

assert_eq!(half_minute.checked_add(quater_minute), Some(three_quater_minute));
assert_eq!(MicroSeconds::MAX.checked_add(half_minute), None);

pub fn checked_add_duration(self, rhs: Duration) -> Option<Self>

Checked integer addition. Computes self + rhs, returning None if overflow occurred, using the inner integer’s checked_add() method.

Examples

let half_minute = MicroSeconds(30 * MICROS_PER_SEC);
let duration1 = Duration::new(2, 5 * NANOS_PER_MICRO + 20); // 2s + 5us + 20ns
let duration2 = Duration::new(MicroSeconds::MAX.inner() / MICROS_PER_SEC, 0);

assert_eq!(half_minute.checked_add_duration(duration1), Some(MicroSeconds(32_000_005)));
assert_eq!(half_minute.checked_add_duration(duration2), None);

pub fn checked_sub(self, other: Self) -> Option<Self>

Checked integer subtraction. Computes self - rhs, returning None if overflow occurred, using the inner integer’s checked_sub() method.

Examples

let quater_minute = MicroSeconds(15 * MICROS_PER_SEC);
let three_quater_minute = MicroSeconds(45 * MICROS_PER_SEC);
let whole_minute = MicroSeconds(60 * MICROS_PER_SEC);

assert_eq!(whole_minute.checked_sub(quater_minute), Some(three_quater_minute));
assert_eq!(quater_minute.checked_sub(whole_minute), None);

pub fn checked_sub_duration(self, rhs: Duration) -> Option<Self>

Checked integer subtraction. Computes self - rhs, returning None if overflow occurred, using the inner integer’s checked_sub() method.

Examples

let half_minute = MicroSeconds(30 * MICROS_PER_SEC);
let duration1 = Duration::new(2, 5 * NANOS_PER_MICRO + 20); // 2s + 5us + 20ns
let duration2 = Duration::new(45, 0);

assert_eq!(half_minute.checked_sub_duration(duration1), Some(MicroSeconds(27_999_995)));
assert_eq!(half_minute.checked_sub_duration(duration2), None);

pub fn checked_mul(self, rhs: u32) -> Option<Self>

Checked integer multiplication. Computes self * rhs, returning None if overflow occurred, using the inner integer’s checked_mul() method.

Examples

let quater_minute = MicroSeconds(15 * MICROS_PER_SEC);
let whole_minute = MicroSeconds(60 * MICROS_PER_SEC);

assert_eq!(quater_minute.checked_mul(4), Some(whole_minute));
assert_eq!(MicroSeconds::MAX.checked_mul(2), None);

pub fn checked_div(self, rhs: u32) -> Option<Self>

Checked integer division. Computes self / rhs, returning None if rhs == 0, using the inner integer’s checked_div() method.

Examples

let quater_minute = MicroSeconds(15 * MICROS_PER_SEC);
let whole_minute = MicroSeconds(60 * MICROS_PER_SEC);

assert_eq!(whole_minute.checked_div(4), Some(quater_minute));
assert_eq!(whole_minute.checked_div(0), None);

pub fn checked_rem(self, rhs: u32) -> Option<Self>

Checked integer remainder. Computes self % rhs, returning None if rhs == 0, using the inner integer’s checked_rem() method.

Examples

let quater_minute = MicroSeconds(15 * MICROS_PER_SEC);
let whole_minute = MicroSeconds(60 * MICROS_PER_SEC);

assert_eq!(whole_minute.checked_rem(4), Some(MicroSeconds::ZERO));
assert_eq!(whole_minute.checked_rem(7), Some(MicroSeconds(4)));
assert_eq!(whole_minute.checked_rem(0), None);

pub fn mul_f64(self, rhs: f64) -> Self

Multiplies MicroSeconds by f64.

Converts to an f64 representing seconds, multiplies by the given factor, then converts back to microseconds.

Panics if rhs is not finite, is negative, or the value overflows.

Examples

let micros = MicroSeconds(2_700_000_000);

assert_eq!(micros.mul_f64(3.14), MicroSeconds(8_478_000_000));
assert_eq!(micros.mul_f64(3.14e5), MicroSeconds(847_800_000_000_000));

These should panic.

MicroSeconds::SECOND.mul_f64(std::f64::INFINITY);

MicroSeconds::SECOND.mul_f64(-0.5);

MicroSeconds(2 * MICROS_PER_SEC).mul_f64(std::f64::MAX / 10.0);

MicroSeconds::SECOND.mul_f64(std::f64::NAN);

pub fn mul_f32(self, rhs: f32) -> Self

Multiplies MicroSeconds by f32.

Converts to an f32 representing seconds, multiplies by the given factor, then converts back to microseconds.

Panics if rhs is not finite, is negative, or the value overflows.

Examples

let micros = MicroSeconds(2_700_000_000);

// Note the rounding errors that are clear here.
assert_eq!(micros.mul_f32(3.14), MicroSeconds(8_478_000_000));
assert_eq!(micros.mul_f32(3.14e5), MicroSeconds(847_800_000_000_000));

These should panic.

MicroSeconds::SECOND.mul_f32(std::f32::INFINITY);

MicroSeconds::SECOND.mul_f32(-0.5);

MicroSeconds(2 * MICROS_PER_SEC).mul_f32(std::f32::MAX / 10.0);

MicroSeconds::SECOND.mul_f32(std::f32::NAN);

pub fn div_f64(self, rhs: f64) -> Self

Divides MicroSeconds by f64.

Converts to an f64 representing seconds, divides by the given factor, then converts back to microseconds.

Panics if rhs is not finite, is negative, or the value overflows.

Examples

let micros = MicroSeconds(2_700_000_000);

assert_eq!(micros.div_f64(3.14), MicroSeconds(859_872_611));
assert_eq!(micros.div_f64(3.14e5), MicroSeconds(8_598));

These should panic.

MicroSeconds::SECOND.div_f64(-2.0);

MicroSeconds::MAX.div_f64(0.5);

MicroSeconds::SECOND.div_f64(std::f64::NAN);

pub fn div_f32(self, rhs: f32) -> Self

Divides MicroSeconds by f32.

Converts to an f32 representing seconds, divides by the given factor, then converts back to microseconds.

Panics if rhs is not finite, is negative, or the value overflows.

Examples

let micros = MicroSeconds(2_700_000_000);

assert_eq!(micros.div_f32(3.14), MicroSeconds(859_872_558));
assert_eq!(micros.div_f32(3.14e5), MicroSeconds(8_598));

These should panic.

MicroSeconds::SECOND.div_f32(-2.0);

MicroSeconds::MAX.div_f32(0.5);

MicroSeconds::SECOND.div_f32(std::f32::NAN);

Trait Implementations

impl Add<Duration> for MicroSeconds

type Output = MicroSeconds

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<MicroSeconds> for Duration

type Output = Duration

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<MicroSeconds> for MonotonicTs

type Output = MonotonicTs

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<MicroSeconds> for Timeval

type Output = Timeval

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<MicroSeconds> for UnixTs

type Output = UnixTs

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for MicroSeconds

type Output = MicroSeconds

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<Duration> for MicroSeconds

fn add_assign(&mut self, rhs: Duration)

Performs the += operation.

impl AddAssign<MicroSeconds> for Duration

fn add_assign(&mut self, rhs: MicroSeconds)

Performs the += operation.

impl AddAssign<MicroSeconds> for MonotonicTs

fn add_assign(&mut self, rhs: MicroSeconds)

Performs the += operation.

impl AddAssign<MicroSeconds> for Timeval

fn add_assign(&mut self, rhs: MicroSeconds)

Performs the += operation.

impl AddAssign<MicroSeconds> for UnixTs

fn add_assign(&mut self, rhs: MicroSeconds)

Performs the += operation.

impl AddAssign for MicroSeconds

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for MicroSeconds

fn clone(&self) -> MicroSeconds

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MicroSeconds

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

Formats the value using the given formatter.

impl Default for MicroSeconds

fn default() -> MicroSeconds

Returns the “default value” for a type.

impl Display for MicroSeconds

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

Formats the value using the given formatter.

impl Div<u32> for MicroSeconds

type Output = MicroSeconds

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<u32> for MicroSeconds

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl From<MicroSeconds> for Duration

fn from(t: MicroSeconds) -> Self

Converts to this type from the input type.

impl From<MicroSeconds> for Timeval

fn from(t: MicroSeconds) -> Self

Converts to this type from the input type.

impl From<Timeval> for MicroSeconds

fn from(t: Timeval) -> Self

Converts to this type from the input type.

impl Mul<MicroSeconds> for u32

type Output = MicroSeconds

The resulting type after applying the * operator.

fn mul(self, rhs: MicroSeconds) -> MicroSeconds

Performs the * operation.

impl Mul<u32> for MicroSeconds

type Output = MicroSeconds

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<u32> for MicroSeconds

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl Ord for MicroSeconds

fn cmp(&self, other: &MicroSeconds) -> 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 MicroSeconds

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

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

type Output = MicroSeconds

The resulting type after applying the % operator.

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

Performs the % operation.

impl RemAssign<u32> for MicroSeconds

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

impl Sub<Duration> for MicroSeconds

type Output = MicroSeconds

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<MicroSeconds> for Duration

type Output = Duration

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<MicroSeconds> for MonotonicTs

type Output = MonotonicTs

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<MicroSeconds> for Timeval

type Output = Timeval

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<MicroSeconds> for UnixTs

type Output = UnixTs

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for MicroSeconds

type Output = MicroSeconds

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<Duration> for MicroSeconds

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation.

impl SubAssign<MicroSeconds> for Duration

fn sub_assign(&mut self, rhs: MicroSeconds)

Performs the -= operation.

impl SubAssign<MicroSeconds> for MonotonicTs

fn sub_assign(&mut self, rhs: MicroSeconds)

Performs the -= operation.

impl SubAssign<MicroSeconds> for Timeval

fn sub_assign(&mut self, rhs: MicroSeconds)

Performs the -= operation.

impl SubAssign<MicroSeconds> for UnixTs

fn sub_assign(&mut self, rhs: MicroSeconds)

Performs the -= operation.

impl SubAssign for MicroSeconds

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl TryFrom<Duration> for MicroSeconds

type Error = ()

The type returned in the event of a conversion error.

fn try_from(t: Duration) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for MicroSeconds

impl Eq for MicroSeconds

impl StructuralPartialEq for MicroSeconds