Struct TimePoint 

pub struct TimePoint<T: Timeline> { /* private fields */ }

A point on timeline T: a tick count since the timeline’s zero.

Points on one timeline compare, subtract to Ticks, and can be written down as a tick count and read back (ticks, from_ticks). Points on different timelines do not compare at all, because their types differ:

use core::num::NonZeroU64;
use win_time_sys::{TimePoint, Timeline};

enum Boot {}
impl Timeline for Boot {
    fn ticks_per_second() -> NonZeroU64 { NonZeroU64::new(10_000_000).unwrap() }
}
enum Calendar {}
impl Timeline for Calendar {
    fn ticks_per_second() -> NonZeroU64 { NonZeroU64::new(10_000_000).unwrap() }
}

// The same unit, but not the same zero: refused.
let _ = TimePoint::<Boot>::from_ticks(1) < TimePoint::<Calendar>::from_ticks(2);

Implementations

impl<T: Timeline> TimePoint<T>

pub const fn from_ticks(ticks: u64) -> Self

The point ticks after the timeline’s zero: how a recorded point is read back.

Examples found in repository

examples/clock_costs/main.rs (line 106)

fn clock_nanos<C: Clock>(clock: &C) -> u128 {
    let since_zero = clock.now() - TimePoint::from_ticks(0);
    since_zero.abs_duration().as_nanos()
}

pub const fn ticks(self) -> u64

The tick count since the timeline’s zero: how a point is recorded.

pub fn checked_since(self, earlier: Self) -> Option<Ticks<T>>

How far this point is after earlier – negative if it is before – or None if the distance does not fit in Ticks.

pub fn checked_add(self, ticks: Ticks<T>) -> Option<Self>

The point ticks later, or None if it falls outside the timeline.

pub fn checked_sub(self, ticks: Ticks<T>) -> Option<Self>

The point ticks earlier, or None if it falls outside the timeline.

Trait Implementations

impl<T: Timeline> Add<Ticks<T>> for TimePoint<T>

type Output = TimePoint<T>

The resulting type after applying the + operator.

fn add(self, ticks: Ticks<T>) -> Self

Performs the + operation.

impl<T: Timeline> AddAssign<Ticks<T>> for TimePoint<T>

fn add_assign(&mut self, ticks: Ticks<T>)

Performs the += operation.

impl<T: Timeline> Clone for TimePoint<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Timeline> Copy for TimePoint<T>

impl<T: Timeline> Debug for TimePoint<T>

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

Formats the value using the given formatter.

impl<T: Timeline> Eq for TimePoint<T>

impl<T: Timeline> Hash for TimePoint<T>

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<T: Timeline> Ord for TimePoint<T>

fn cmp(&self, other: &Self) -> 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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl<T: Timeline> PartialEq for TimePoint<T>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: Timeline> PartialOrd for TimePoint<T>

fn partial_cmp(&self, other: &Self) -> 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<T: Timeline> Sub for TimePoint<T>

type Output = Ticks<T>

The resulting type after applying the - operator.

fn sub(self, earlier: Self) -> Ticks<T>

Performs the - operation.

impl<T: Timeline> Sub<Ticks<T>> for TimePoint<T>

type Output = TimePoint<T>

The resulting type after applying the - operator.

fn sub(self, ticks: Ticks<T>) -> Self

Performs the - operation.

impl<T: Timeline> SubAssign<Ticks<T>> for TimePoint<T>

fn sub_assign(&mut self, ticks: Ticks<T>)

Performs the -= operation.