Struct fugit::Instant

pub struct Instant<T, const NOM: u32, const DENOM: u32> { /* private fields */ }

Represents an instant in time.

The generic T can either be u32 or u64, and the const generics represent the ratio of the ticks contained within the instant: instant in seconds = NOM / DENOM * ticks

Implementations

impl<const NOM: u32, const DENOM: u32> Instant<u32, NOM, DENOM>

pub const fn from_ticks(ticks: u32) -> Self

Create an Instant from a ticks value.

let _i = Instant::<u32, 1, 1_000>::from_ticks(1);

pub const fn ticks(&self) -> u32

Extract the ticks from an Instant.

let i = Instant::<u32, 1, 1_000>::from_ticks(234);

assert_eq!(i.ticks(), 234);

pub const fn const_cmp(self, other: Self) -> Ordering

Const comparison of Instants.

let i1 = Instant::<u32, 1, 1_000>::from_ticks(1);
let i2 = Instant::<u32, 1, 1_000>::from_ticks(2);

assert_eq!(i1.const_cmp(i2), core::cmp::Ordering::Less);

This function takes into account that ticks might wrap around. If the absolute values of self and other differ by more than half the possible range, it is assumed that an overflow occured and the result is reversed:

let i1 = Instant::<u32, 1, 1_000>::from_ticks(u32::MAX);
let i2 = Instant::<u32, 1, 1_000>::from_ticks(1);

assert_eq!(i1.const_cmp(i2), core::cmp::Ordering::Less);

pub const fn duration_since_epoch(self) -> Duration<u32, NOM, DENOM>

Duration between since the start of the Instant. This assumes an instant which won’t wrap within the execution of the program.

let i = Instant::<u32, 1, 1_000>::from_ticks(11);

assert_eq!(i.duration_since_epoch().ticks(), 11);

pub const fn checked_duration_since( self, other: Self, ) -> Option<Duration<u32, NOM, DENOM>>

Duration between Instants.

let i1 = Instant::<u32, 1, 1_000>::from_ticks(1);
let i2 = Instant::<u32, 1, 1_000>::from_ticks(2);

assert_eq!(i1.checked_duration_since(i2), None);
assert_eq!(i2.checked_duration_since(i1).unwrap().ticks(), 1);

pub const fn checked_sub_duration<const O_NOM: u32, const O_DENOM: u32>( self, other: Duration<u32, O_NOM, O_DENOM>, ) -> Option<Self>

Subtract a Duration from an Instant while checking for overflow.

let i = Instant::<u32, 1, 1_000>::from_ticks(1);
let d = Duration::<u32, 1, 1_000>::from_ticks(1);

assert_eq!(i.checked_sub_duration(d).unwrap().ticks(), 0);

pub const fn checked_add_duration<const O_NOM: u32, const O_DENOM: u32>( self, other: Duration<u32, O_NOM, O_DENOM>, ) -> Option<Self>

Add a Duration to an Instant while checking for overflow.

let i = Instant::<u32, 1, 1_000>::from_ticks(1);
let d = Duration::<u32, 1, 1_000>::from_ticks(1);

assert_eq!(i.checked_add_duration(d).unwrap().ticks(), 2);

impl<const NOM: u32, const DENOM: u32> Instant<u64, NOM, DENOM>

pub const fn from_ticks(ticks: u64) -> Self

Create an Instant from a ticks value.

let _i = Instant::<u64, 1, 1_000>::from_ticks(1);

pub const fn ticks(&self) -> u64

Extract the ticks from an Instant.

let i = Instant::<u64, 1, 1_000>::from_ticks(234);

assert_eq!(i.ticks(), 234);

pub const fn const_cmp(self, other: Self) -> Ordering

Const comparison of Instants.

let i1 = Instant::<u64, 1, 1_000>::from_ticks(1);
let i2 = Instant::<u64, 1, 1_000>::from_ticks(2);

assert_eq!(i1.const_cmp(i2), core::cmp::Ordering::Less);

This function takes into account that ticks might wrap around. If the absolute values of self and other differ by more than half the possible range, it is assumed that an overflow occured and the result is reversed:

let i1 = Instant::<u64, 1, 1_000>::from_ticks(u64::MAX);
let i2 = Instant::<u64, 1, 1_000>::from_ticks(1);

assert_eq!(i1.const_cmp(i2), core::cmp::Ordering::Less);

pub const fn duration_since_epoch(self) -> Duration<u64, NOM, DENOM>

Duration between since the start of the Instant. This assumes an instant which won’t wrap within the execution of the program.

let i = Instant::<u64, 1, 1_000>::from_ticks(11);

assert_eq!(i.duration_since_epoch().ticks(), 11);

pub const fn checked_duration_since( self, other: Self, ) -> Option<Duration<u64, NOM, DENOM>>

Duration between Instants.

let i1 = Instant::<u64, 1, 1_000>::from_ticks(1);
let i2 = Instant::<u64, 1, 1_000>::from_ticks(2);

assert_eq!(i1.checked_duration_since(i2), None);
assert_eq!(i2.checked_duration_since(i1).unwrap().ticks(), 1);

pub const fn checked_sub_duration<const O_NOM: u32, const O_DENOM: u32>( self, other: Duration<u64, O_NOM, O_DENOM>, ) -> Option<Self>

Subtract a Duration from an Instant while checking for overflow.

let i = Instant::<u64, 1, 1_000>::from_ticks(1);
let d = Duration::<u64, 1, 1_000>::from_ticks(1);

assert_eq!(i.checked_sub_duration(d).unwrap().ticks(), 0);

pub const fn checked_add_duration<const O_NOM: u32, const O_DENOM: u32>( self, other: Duration<u64, O_NOM, O_DENOM>, ) -> Option<Self>

Add a Duration to an Instant while checking for overflow.

let i = Instant::<u64, 1, 1_000>::from_ticks(1);
let d = Duration::<u64, 1, 1_000>::from_ticks(1);

assert_eq!(i.checked_add_duration(d).unwrap().ticks(), 2);

Trait Implementations

impl<const NOM: u32, const DENOM: u32> Add<Duration<u32, NOM, DENOM>> for Instant<u32, NOM, DENOM>

type Output = Instant<u32, NOM, DENOM>

The resulting type after applying the + operator.

fn add(self, other: Duration<u32, NOM, DENOM>) -> Self::Output

Performs the + operation.

impl<const NOM: u32, const DENOM: u32> Add<Duration<u32, NOM, DENOM>> for Instant<u64, NOM, DENOM>

type Output = Instant<u64, NOM, DENOM>

The resulting type after applying the + operator.

fn add(self, other: Duration<u32, NOM, DENOM>) -> Self::Output

Performs the + operation.

impl<const NOM: u32, const DENOM: u32> Add<Duration<u64, NOM, DENOM>> for Instant<u64, NOM, DENOM>

type Output = Instant<u64, NOM, DENOM>

The resulting type after applying the + operator.

fn add(self, other: Duration<u64, NOM, DENOM>) -> Self::Output

Performs the + operation.

impl<const NOM: u32, const DENOM: u32> AddAssign<Duration<u32, NOM, DENOM>> for Instant<u32, NOM, DENOM>

fn add_assign(&mut self, other: Duration<u32, NOM, DENOM>)

Performs the += operation.

impl<const NOM: u32, const DENOM: u32> AddAssign<Duration<u32, NOM, DENOM>> for Instant<u64, NOM, DENOM>

fn add_assign(&mut self, other: Duration<u32, NOM, DENOM>)

Performs the += operation.

impl<const NOM: u32, const DENOM: u32> AddAssign<Duration<u64, NOM, DENOM>> for Instant<u64, NOM, DENOM>

fn add_assign(&mut self, other: Duration<u64, NOM, DENOM>)

Performs the += operation.

impl<T: Clone, const NOM: u32, const DENOM: u32> Clone for Instant<T, NOM, DENOM>

fn clone(&self) -> Instant<T, NOM, DENOM>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const NOM: u32, const DENOM: u32> Debug for Instant<T, NOM, DENOM>

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

Formats the value using the given formatter.

impl<const NOM: u32, const DENOM: u32> Display for Instant<u32, NOM, DENOM>

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

Formats the value using the given formatter.

impl<const NOM: u32, const DENOM: u32> Display for Instant<u64, NOM, DENOM>

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

Formats the value using the given formatter.

impl<const NOM: u32, const DENOM: u32> Ord for Instant<u32, NOM, DENOM>

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

This implementation deviates from the definition of Ord::cmp:

It takes into account that ticks might wrap around. If the absolute values of self and other differ by more than half the possible range, it is assumed that an overflow occured and the result is reversed.

That breaks the transitivity invariant: a < b and b < c no longer implies a < c.

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 + PartialOrd,

Restrict a value to a certain interval.

impl<const NOM: u32, const DENOM: u32> Ord for Instant<u64, NOM, DENOM>

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

This implementation deviates from the definition of Ord::cmp:

It takes into account that ticks might wrap around. If the absolute values of self and other differ by more than half the possible range, it is assumed that an overflow occured and the result is reversed.

That breaks the transitivity invariant: a < b and b < c no longer implies a < c.

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 + PartialOrd,

Restrict a value to a certain interval.

impl<const NOM: u32, const DENOM: u32> PartialEq for Instant<u32, NOM, DENOM>

fn eq(&self, other: &Self) -> 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<const NOM: u32, const DENOM: u32> PartialEq for Instant<u64, NOM, DENOM>

fn eq(&self, other: &Self) -> 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<const NOM: u32, const DENOM: u32> PartialOrd for Instant<u32, NOM, DENOM>

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

This implementation deviates from the definition of PartialOrd::partial_cmp:

It takes into account that ticks might wrap around. If the absolute values of self and other differ by more than half the possible range, it is assumed that an overflow occured and the result is reversed.

That breaks the transitivity invariant: a < b and b < c no longer implies a < c.

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<const NOM: u32, const DENOM: u32> PartialOrd for Instant<u64, NOM, DENOM>

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

This implementation deviates from the definition of PartialOrd::partial_cmp:

It takes into account that ticks might wrap around. If the absolute values of self and other differ by more than half the possible range, it is assumed that an overflow occured and the result is reversed.

That breaks the transitivity invariant: a < b and b < c no longer implies a < c.

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<const NOM: u32, const DENOM: u32> Sub<Duration<u32, NOM, DENOM>> for Instant<u32, NOM, DENOM>

type Output = Instant<u32, NOM, DENOM>

The resulting type after applying the - operator.

fn sub(self, other: Duration<u32, NOM, DENOM>) -> Self::Output

Performs the - operation.

impl<const NOM: u32, const DENOM: u32> Sub<Duration<u32, NOM, DENOM>> for Instant<u64, NOM, DENOM>

type Output = Instant<u64, NOM, DENOM>

The resulting type after applying the - operator.

fn sub(self, other: Duration<u32, NOM, DENOM>) -> Self::Output

Performs the - operation.

impl<const NOM: u32, const DENOM: u32> Sub<Duration<u64, NOM, DENOM>> for Instant<u64, NOM, DENOM>

type Output = Instant<u64, NOM, DENOM>

The resulting type after applying the - operator.

fn sub(self, other: Duration<u64, NOM, DENOM>) -> Self::Output

Performs the - operation.

impl<const NOM: u32, const DENOM: u32> Sub for Instant<u32, NOM, DENOM>

type Output = Duration<u32, NOM, DENOM>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const NOM: u32, const DENOM: u32> Sub for Instant<u64, NOM, DENOM>

type Output = Duration<u64, NOM, DENOM>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const NOM: u32, const DENOM: u32> SubAssign<Duration<u32, NOM, DENOM>> for Instant<u32, NOM, DENOM>

fn sub_assign(&mut self, other: Duration<u32, NOM, DENOM>)

Performs the -= operation.

impl<const NOM: u32, const DENOM: u32> SubAssign<Duration<u32, NOM, DENOM>> for Instant<u64, NOM, DENOM>

fn sub_assign(&mut self, other: Duration<u32, NOM, DENOM>)

Performs the -= operation.

impl<const NOM: u32, const DENOM: u32> SubAssign<Duration<u64, NOM, DENOM>> for Instant<u64, NOM, DENOM>

fn sub_assign(&mut self, other: Duration<u64, NOM, DENOM>)

Performs the -= operation.

impl<T: Copy, const NOM: u32, const DENOM: u32> Copy for Instant<T, NOM, DENOM>

impl<const NOM: u32, const DENOM: u32> Eq for Instant<u32, NOM, DENOM>

impl<const NOM: u32, const DENOM: u32> Eq for Instant<u64, NOM, DENOM>