Struct TimespecInstant 

pub struct TimespecInstant { /* private fields */ }

An Instant type inspired by the timespec struct from the C standard library

This instant type is implemented in a similar way as the Duration type because they both use a struct of seconds and (subsecond) nanoseconds to represent time. This has the great benefit that additions and subtractions do not require divisions, see the documentation to Instant32 and Instant64.

The main drawback of this instant type might be that creating these instants is harder. It can be done in basically two ways:

1. The underlying clock uses a simple integer tick counter. In these cases, creating each instant requires the division which is saved when working with the instants. Depending on the use case, this might be more or less efficient than using Instant32 or Instant64.
2. The underlying clock works on a similar seconds+nanoseconds struct directly. In these cases, creating an instant is easy but incrementing the underlying value in the clock tick interrupt gets harder. It is harder because the clock tick interrupt handler needs to take care of the nanosecond overflow which happens once per second and which needs to be properly synchronized with the contexts which request instants. Note though, that this might be the same problem as implementing a clock for Instant32 or Instant64 on platforms that do not support the corresponding atomic types. Especially on widespread 32 bit platforms, the AtomicU64 might be missing.

Also, if you are especially concerned about data sizes, Instant32 might be more appropriate for you because this type uses a 64 bit representation, see below.

The seconds and nanoseconds are both stored as u32 values. For the nanoseconds, this should be obvious. For the seconds, using a 32 bit integer might remind of the year 2038 problem but this is only relevant when working with wall clock times. Since Instant is about working with monotonic clocks which can always be measured since program or system start, this would only be relevant if the program or system was designed to run for longer than about 136 years. So this should affect nearly no users at all. Therefore, saving additional bits seems reasonable.

Implementations

impl TimespecInstant

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

Create a new TimespecInstant

Trait Implementations

impl Add<Duration> for TimespecInstant

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

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.

type Output = TimespecInstant

The resulting type after applying the + operator.

impl AddAssign<Duration> for TimespecInstant

fn add_assign(&mut self, other: Duration)

Performs the += operation.

impl Clone for TimespecInstant

fn clone(&self) -> TimespecInstant

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TimespecInstant

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

Formats the value using the given formatter.

impl Hash for TimespecInstant

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Instant for TimespecInstant

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

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

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

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

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

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.

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

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

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

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

impl Ord for TimespecInstant

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

This method returns an Ordering between self and other.

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,

Restrict a value to a certain interval.

impl PartialEq for TimespecInstant

fn eq(&self, other: &TimespecInstant) -> 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 PartialOrd for TimespecInstant

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

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

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 Sub<Duration> for TimespecInstant

type Output = TimespecInstant

The resulting type after applying the - operator.

fn sub(self, other: Duration) -> TimespecInstant

Performs the - operation.

impl Sub for TimespecInstant

fn sub(self, other: TimespecInstant) -> Duration

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

Panics

As in the current version of the Rust stdlib, this method saturates instead of panicking.

type Output = Duration

The resulting type after applying the - operator.

impl SubAssign<Duration> for TimespecInstant

fn sub_assign(&mut self, other: Duration)

Performs the -= operation.

impl Copy for TimespecInstant

impl Eq for TimespecInstant

impl StructuralPartialEq for TimespecInstant