Struct rtic_monotonic::Instant [−][src]
pub struct Instant<Clock> where
Clock: Clock, { /* fields omitted */ }
Expand description
Represents an instant of time relative to a specific Clock
Example
Typically an Instant
will be obtained from a Clock
let some_clock = SomeClock;
let some_instant = some_clock.try_now().unwrap();
However, an Instant
can also be constructed directly. In this case the constructed Instant
is 23 * SomeClock::SCALING_FACTOR
seconds since the clock’s epoch
Instant::<SomeClock>::new(23);
Implementations
Construct a new Instant from the provided Clock
Returns the amount of time elapsed from another instant to this one as a
duration::Generic
or None
if the other instant is later than
this one.
Examples
struct Clock;
impl embedded_time::Clock for Clock {
type T = u32;
const SCALING_FACTOR: Fraction = Fraction::new(1, 1_000);
// ...
}
// Given `instant1` at 3 `Clock` ticks
// Given `instant2` at 5 `Clock` ticks
let generic_duration = instant2.checked_duration_since(&instant1).unwrap();
// Convert into a _named_ `Duration`
let microseconds: Microseconds<u32> = generic_duration.try_into().unwrap();
assert_eq!(microseconds, Microseconds(2_000_u32));
Returns the amount of time elapsed from self until that given instant
duration::Generic
or None
if the other instant is later than
this one.
Examples
struct Clock;
impl embedded_time::Clock for Clock {
type T = u32;
const SCALING_FACTOR: Fraction = Fraction::new(1, 1_000);
// ...
}
// Given `instant1` at 3 `Clock` ticks
// Given `instant2` at 5 `Clock` ticks
let generic_duration = instant1.checked_duration_until(&instant2).unwrap();
// Convert into a _named_ `Duration`
let microseconds: Microseconds<u32> = generic_duration.try_into().unwrap();
assert_eq!(microseconds, Microseconds(2_000_u32));
This Instant
+ Duration
= later (future) Instant
Returns None
if the Duration
is too large
Examples
struct Clock;
impl embedded_time::Clock for Clock {
type T = u32;
const SCALING_FACTOR: Fraction = Fraction::new(1, 1_000);
// ...
}
assert_eq!(
Instant::<Clock>::new(0).checked_add(Milliseconds(u32::MAX/2)),
Some(Instant::<Clock>::new(u32::MAX/2))
);
assert_eq!(
Instant::<Clock>::new(0).checked_add(Milliseconds(u32::MAX/2 + 1)),
None
);
This Instant
- Duration
= earlier Instant
Returns None
if the Duration
is too large
Examples
struct Clock;
impl embedded_time::Clock for Clock {
type T = u32;
const SCALING_FACTOR: Fraction = Fraction::new(1, 1_000);
// ...
}
assert_eq!(Instant::<Clock>::new(u32::MAX).checked_sub(Milliseconds(u32::MAX/2)),
Some(Instant::<Clock>::new(u32::MAX - u32::MAX/2)));
assert_eq!(Instant::<Clock>::new(u32::MAX).checked_sub(Milliseconds(u32::MAX/2 + 1)),
None);
Trait Implementations
Add a Duration
to an Instant
resulting in a new, later Instant
Examples
struct Clock;
impl embedded_time::Clock for Clock {
type T = u32;
const SCALING_FACTOR: Fraction = Fraction::new(1, 1_000);
// ...
}
assert_eq!(Instant::<Clock>::new(1) + Seconds(3_u32),
Instant::<Clock>::new(3_001));
assert_eq!(Instant::<Clock>::new(1) + Milliseconds(700_u32),
Instant::<Clock>::new(701));
assert_eq!(Instant::<Clock>::new(1) + Milliseconds(700_u64),
Instant::<Clock>::new(701));
// maximum duration allowed
assert_eq!(Instant::<Clock>::new(0) + Milliseconds(i32::MAX as u32),
Instant::<Clock>::new(u32::MAX/2));
Panics
Virtually the same reason the integer operation would panic. Namely, if the result overflows the type. Specifically, if the duration is more than half the wrap-around period of the clock.
struct Clock;
impl embedded_time::Clock for Clock {
type T = u32;
const SCALING_FACTOR: Fraction = Fraction::new(1, 1_000);
// ...
}
Instant::<Clock>::new(0) + Milliseconds(u32::MAX/2 + 1);
Calculates the difference between two Instant
s resulting in a Duration
struct Clock;
impl embedded_time::Clock for Clock {
type T = u32;
const SCALING_FACTOR: Fraction = Fraction::new(1, 1_000);
// ...
}
assert!(Instant::<Clock>::new(5) > Instant::<Clock>::new(3));
assert!(Instant::<Clock>::new(5) == Instant::<Clock>::new(5));
assert!(Instant::<Clock>::new(u32::MAX) < Instant::<Clock>::new(u32::MIN));
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
Subtract a Duration
from an Instant
resulting in a new, earlier Instant
Examples
struct Clock;
impl embedded_time::Clock for Clock {
type T = u32;
const SCALING_FACTOR: Fraction = Fraction::new(1, 1_000);
// ...
}
assert_eq!(Instant::<Clock>::new(5_001) - Seconds(3_u32),
Instant::<Clock>::new(2_001));
assert_eq!(Instant::<Clock>::new(800) - Milliseconds(700_u32),
Instant::<Clock>::new(100));
assert_eq!(Instant::<Clock>::new(5_000) - Milliseconds(700_u64),
Instant::<Clock>::new(4_300));
// maximum duration allowed
assert_eq!(Instant::<Clock>::new(u32::MAX) - Milliseconds(i32::MAX as u32),
Instant::<Clock>::new(u32::MAX/2 + 1));
Panics
Virtually the same reason the integer operation would panic. Namely, if the result overflows the type. Specifically, if the duration is more than half the wrap-around period of the clock.
struct Clock;
impl embedded_time::Clock for Clock {
type T = u32;
const SCALING_FACTOR: Fraction = Fraction::new(1, 1_000);
// ...
}
Instant::<Clock>::new(u32::MAX) - Milliseconds(u32::MAX/2 + 1);
Subtract a two Instant
s resulting in a Duration
Examples
struct Clock;
impl embedded_time::Clock for Clock {
type T = u32;
const SCALING_FACTOR: Fraction = Fraction::new(1, 1_000);
// ...
}
assert_eq!((Instant::<Clock>::new(5_001) - Instant::<Clock>::new(5_000)).integer(), 1);
Panics
Virtually the same reason the integer operation would panic. Namely, if the
result overflows the type. Specifically, if the right hand side Instant
is
larger than the left hand side.
struct Clock;
impl embedded_time::Clock for Clock {
type T = u32;
const SCALING_FACTOR: Fraction = Fraction::new(1, 1_000);
// ...
}
Instant::<Clock>::new(0) - Instant::<Clock>::new(1);