Struct quanta::Instant

source ·

pub struct Instant(/* private fields */);

Expand description

A point-in-time wall-clock measurement.

Unlike the stdlib Instant, this type has a meaningful difference: it is intended to be opaque, but the internal value can be accessed. There are no guarantees here and depending on this value directly is proceeding at your own risk. ⚠️

An Instant is 8 bytes.

Implementations§

source §

impl Instant

source

pub fn now() -> Instant

Gets the current time, scaled to reference time.

This method depends on a lazily initialized global clock, which can take up to 200ms to initialize and calibrate itself.

This method is the spiritual equivalent of std::time::Instant::now. It is guaranteed to return a monotonically increasing value.

source

pub fn recent() -> Instant

Gets the most recent current time, scaled to reference time.

This method provides ultra-low-overhead access to a slightly-delayed version of the current time. Instead of querying the underlying source clock directly, a shared, global value is read directly without the need to scale to reference time.

The value is updated by running an “upkeep” thread or by calling [quanta::set_recent]. An upkeep thread can be configured and spawned via [Builder].

If the upkeep thread has not been started, or no value has been set manually, a lazily initialized global clock will be used to get the current time. This clock can take up to 200ms to initialize and calibrate itself.

source

pub fn duration_since(&self, earlier: Instant) -> Duration

Returns the amount of time elapsed from another instant to this one.

Panics

This function will panic if earlier is later than self.

Examples

use quanta::Clock;
use std::time::Duration;
use std::thread::sleep;

let mut clock = Clock::new();
let now = clock.now();
sleep(Duration::new(1, 0));
let new_now = clock.now();
println!("{:?}", new_now.duration_since(now));

source

pub fn checked_duration_since(&self, earlier: Instant) -> Option<Duration>

Returns the amount of time elapsed from another instant to this one, or None if that instant is earlier than this one.

Examples

use quanta::Clock;
use std::time::Duration;
use std::thread::sleep;

let mut clock = Clock::new();
let now = clock.now();
sleep(Duration::new(1, 0));
let new_now = clock.now();
println!("{:?}", new_now.checked_duration_since(now));
println!("{:?}", now.checked_duration_since(new_now)); // None

source

pub fn saturating_duration_since(&self, earlier: Instant) -> Duration

Returns the amount of time elapsed from another instant to this one, or zero duration if that instant is earlier than this one.

Examples

use quanta::Clock;
use std::time::Duration;
use std::thread::sleep;

let mut clock = Clock::new();
let now = clock.now();
sleep(Duration::new(1, 0));
let new_now = clock.now();
println!("{:?}", new_now.saturating_duration_since(now));
println!("{:?}", now.saturating_duration_since(new_now)); // 0ns

source

pub fn checked_add(&self, duration: Duration) -> Option<Instant>

Returns Some(t) where t is the time self + duration if t can be represented as Instant (which means it’s inside the bounds of the underlying data structure), None otherwise.

source

pub fn checked_sub(&self, duration: Duration) -> Option<Instant>

Returns Some(t) where t is the time self - duration if t can be represented as Instant (which means it’s inside the bounds of the underlying data structure), None otherwise.

source

pub fn as_u64(&self) -> u64

Gets the inner value of this Instant.

Trait Implementations§

source §

impl Add<Duration> for Instant

source §

fn add(self, other: Duration) -> Instant

Panics

This function may panic if the resulting point in time cannot be represented by the underlying data structure. See Instant::checked_add for a version without panic.

§