Struct unix_time::Instant

pub struct Instant { /* fields omitted */ }

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

Implementations

impl Instant

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 }");

pub fn now() -> Self

Returns an instant corresponding to "now".

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);

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);

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.

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.

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

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));

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

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

impl Add<Duration> for Instant

type Output = Instant

The resulting type after applying the + operator.

pub 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.

impl AddAssign<Duration> for Instant

pub fn add_assign(&mut self, other: Duration)

Performs the += operation.

impl Clone for Instant

pub fn clone(&self) -> Instant

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Instant

impl Debug for Instant

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Instant

pub fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Eq for Instant

impl From<Duration> for Instant

pub fn from(d: Duration) -> Instant

Performs the conversion.

impl From<Instant> for Duration

pub fn from(i: Instant) -> Duration

Performs the conversion.

impl Hash for Instant

pub fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Ord for Instant

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

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Instant> for Instant

pub fn eq(&self, other: &Instant) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Instant) -> bool

This method tests for !=.

impl PartialOrd<Instant> for Instant

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

This method returns an ordering between self and other values if one exists.

pub fn lt(&self, other: &Instant) -> bool

This method tests less than (for self and other) and is used by the < operator.

pub fn le(&self, other: &Instant) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

pub fn gt(&self, other: &Instant) -> bool

This method tests greater than (for self and other) and is used by the > operator.

pub fn ge(&self, other: &Instant) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Instant

pub fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralEq for Instant

impl StructuralPartialEq for Instant

impl Sub<Duration> for Instant

type Output = Instant

The resulting type after applying the - operator.

pub fn sub(self, other: Duration) -> Instant

Performs the - operation.

impl Sub<Instant> for Instant

type Output = Duration

The resulting type after applying the - operator.

pub fn sub(self, other: Instant) -> Duration

Performs the - operation.

impl SubAssign<Duration> for Instant

pub fn sub_assign(&mut self, other: Duration)

Performs the -= operation.