Struct r3_core::time::Time

#[repr(transparent)]
pub struct Time { /* private fields */ }

Represents a timestamp used by the API surface of R3-OS.

The origin is application-defined. If an application desires to represent a calender time using Time, it’s recommended to use the midnight UTC on January 1, 1970 (a.k.a. “UNIX timestamp”) as the origin.

Time is backed by u64 and can represent up to 213,503,982 days with microsecond precision.

Implementations

impl Time

pub const ZERO: Self = _

Zero (the origin).

pub const MAX: Self = _

The large representable timestamp.

pub const fn from_micros(micros: u64) -> Self

Construct a new Time from the specified number of microseconds.

pub const fn from_millis(millis: u64) -> Self

Construct a new Time from the specified number of milliseconds.

Pancis if millis overflows the representable range of Time.

pub const fn from_secs(secs: u64) -> Self

Construct a new Time from the specified number of seconds.

Pancis if secs overflows the representable range of Time.

pub const fn as_micros(self) -> u64

Get the total number of whole microseconds contained in the time span between this Time and Self::ZERO.

pub const fn as_millis(self) -> u64

Get the total number of whole milliseconds contained in the time span between this Time and Self::ZERO.

pub const fn as_secs(self) -> u64

Get the total number of whole seconds contained in the time span between this Time and Self::ZERO.

pub const fn as_secs_f64(self) -> f64

Get the total number of seconds contained in the time span between this Time and Self::ZERO as f64.

Examples

use r3_core::time::Time;

let dur = Time::from_micros(1_201_250_000);
assert_eq!(dur.as_secs_f64(), 1201.25);

pub const fn as_secs_f32(self) -> f32

Get the total number of seconds contained in the time span between this Time and Self::ZERO as f32.

Examples

use r3_core::time::Time;

let dur = Time::from_micros(1_201_250_000);
assert_eq!(dur.as_secs_f32(), 1201.25);

pub const fn core_duration_since_origin(self) -> Duration

Get the duration since the origin as ::core::time::Duration.

pub const fn core_duration_since(self, reference: Self) -> Option<Duration>

Get the duration since the specified timestamp as ::core::time::Duration. Returns None if self < reference.

pub const fn duration_since(self, reference: Self) -> Option<Duration>

Get the duration since the specified timestamp as Duration. Returns None if the result overflows the representable range of Duration.

pub const fn wrapping_add(&self, duration: Duration) -> Self

Advance the time by duration and return the result.

pub const fn wrapping_sub(&self, duration: Duration) -> Self

Put back the time by duration and return the result.

Trait Implementations

impl Add<Duration> for Time

fn add(self, rhs: Duration) -> Self::Output

Advance the time by duration and return the result.

type Output = Time

The resulting type after applying the + operator.

impl AddAssign<Duration> for Time

fn add_assign(&mut self, rhs: Duration)

Advance the time by duration in place.

impl Clone for Time

fn clone(&self) -> Time

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Time

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

Formats the value using the given formatter.

impl Default for Time

fn default() -> Self

Returns the “default value” for a type.

impl Hash for Time

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 Init for Time

const INIT: Self = Self::ZERO

The default value.

impl Ord for Time

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Time> for Time

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Time> for Time

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

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

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

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

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

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

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

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

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

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

impl Sub<Duration> for Time

fn sub(self, rhs: Duration) -> Self::Output

Put back the time by duration and return the result.

type Output = Time

The resulting type after applying the - operator.

impl SubAssign<Duration> for Time

fn sub_assign(&mut self, rhs: Duration)

Put back the time by duration in place.

impl TryFrom<DateTime<Utc>> for Time

fn try_from(value: DateTime<Utc>) -> Result<Self, Self::Error>

Try to construct a Time from the specified chrono_0p4::DateTime<Utc>. Returns an error if the specified DateTime overflows the representable range of the destination type.

The sub-microsecond part is rounded by truncating.

Examples

use chrono_0p4::{DateTime, Utc, TimeZone};
use r3_core::time::Time;
assert_eq!(
    Time::try_from(Utc.timestamp(4, 123_456)),
    Ok(Time::from_micros(4_000_123)),
);
assert!(Time::try_from(Utc.timestamp(-1, 999_999_999)).is_err());

type Error = TryFromDateTimeError

The type returned in the event of a conversion error.

impl TryFrom<Time> for DateTime<Utc>

fn try_from(value: Time) -> Result<Self, Self::Error>

Try to construct a chrono_0p4::DateTime<chrono_0p4::Utc> from the specified Time. Returns an error if the specified Time overflows the representable range of the destination type.

Examples

use chrono_0p4::{DateTime, Utc, TimeZone};
use r3_core::time::Time;
assert_eq!(
    DateTime::try_from(Time::from_micros(123_456_789)),
    Ok(Utc.timestamp(123, 456_789_000)),
);
assert!(
    DateTime::try_from(Time::from_micros(0xffff_ffff_ffff_ffff))
        .is_err()
);

type Error = TryFromDateTimeError

The type returned in the event of a conversion error.

impl Zeroable for Time

fn zeroed() -> Self

Calls zeroed.

impl Copy for Time

impl Eq for Time

impl StructuralEq for Time

impl StructuralPartialEq for Time