Struct Instant

Source

pub struct Instant { /* private fields */ }

Expand description

An precise instant relative to the UNIX epoch, with nanosecond precision.

Implementations§

Source §

impl Instant

Source

pub fn at(secs: u64, nanos: u32) -> Self

Creates an Instant at the specified seconds and nanoseconds after the UNIX epoch.

§Examples

use unix_time::Instant;

let instant = Instant::at(42, 182870024);
assert_eq!(format!("{:?}", instant), "Instant { secs: 42, nanos: 182870024 }");

Source

pub fn now() -> Self

Returns an instant corresponding to “now”.

Source

pub fn secs(&self) -> u64

Returns the number of whole seconds that spaces self from the UNIX epoch.

The returned value does not include the fractional (nanosecond) part of the duration, which can be obtained using subsec_nanos.

§Examples

use unix_time::Instant;

let duration = Instant::at(5, 730023852);
assert_eq!(duration.secs(), 5);

To determine the total number of seconds represented by the Duration, use secs in combination with subsec_nanos:

use unix_time::Instant;

let instant = Instant::at(5, 730023852);

assert_eq!(5.730023852,
           instant.secs() as f64
           + instant.subsec_nanos() as f64 * 1e-9);

Source

pub fn subsec_nanos(&self) -> u32

Returns the fractional part that spaces self from the UNIX epoch in nanoseconds.

This method does not return the total duration since the UNIX epoch in nanoseconds. The returned number always represents a fractional portion of a second (i.e., it is less than one billion).

§Examples

use unix_time::Instant;

let instant = Instant::at(5, 10_000_000);
assert_eq!(instant.secs(), 5);
assert_eq!(instant.subsec_nanos(), 10_000_000);

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 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 later than this one.

§Examples

use unix_time::Instant;
use std::time::Duration;
use std::thread::sleep;

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

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 std::time::Duration;
use unix_time::Instant;
use std::thread::sleep;

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

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 later than this one.

§Examples

use std::time::Duration;
use unix_time::Instant;
use std::thread::sleep;

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

Source

pub fn elapsed(&self) -> Duration

Returns the amount of time elapsed since this instant was created.

§Panics

This function may panic if the current time is earlier than this instant, which is something that can happen if an Instant is produced synthetically.

§Examples

use std::thread::sleep;
use std::time::Duration;
use unix_time::Instant;

let instant = Instant::now();
let three_secs = Duration::from_secs(3);
sleep(three_secs);
assert!(instant.elapsed() >= three_secs);

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.

Source §