Struct nyx_space::time::prelude::Duration

pub struct Duration { /* private fields */ }

Defines generally usable durations for nanosecond precision valid for 32,768 centuries in either direction, and only on 80 bits / 10 octets.

Important conventions: Conventions had to be made to define the partial order of a duration.

1. It was decided that the nanoseconds corresponds to the nanoseconds into the current century. In other words, a durationn with centuries = -1 and nanoseconds = 0 is a smaller duration than centuries = -1 and nanoseconds = 1. That difference is exactly 1 nanoseconds, where the former duration is “closer to zero” than the latter. As such, the largest negative duration that can be represented sets the centuries to i16::MAX and its nanoseconds to NANOSECONDS_PER_CENTURY.
2. It was also decided that opposite durations are equal, e.g. -15 minutes == 15 minutes. If the direction of time matters, use the signum function.

Implementations

impl Duration

pub fn from_parts(centuries: i16, nanoseconds: u64) -> Duration

Create a normalized duration from its parts

pub const fn to_parts(&self) -> (i16, u64)

Returns the centuries and nanoseconds of this duration NOTE: These items are not public to prevent incorrect durations from being created by modifying the values of the structure directly.

pub fn from_total_nanoseconds(nanos: i128) -> Duration

Converts the total nanoseconds as i128 into this Duration (saving 48 bits)

pub fn total_nanoseconds(&self) -> i128

Returns the total nanoseconds in a signed 128 bit integer

pub fn try_truncated_nanoseconds(&self) -> Result<i64, Errors>

Returns the truncated nanoseconds in a signed 64 bit integer, if the duration fits.

pub fn truncated_nanoseconds(&self) -> i64

Returns the truncated nanoseconds in a signed 64 bit integer, if the duration fits. WARNING: This function will NOT fail and will return the i64::MIN or i64::MAX depending on the sign of the centuries if the Duration does not fit on aa i64

pub fn from_truncated_nanoseconds(nanos: i64) -> Duration

Create a new duration from the truncated nanoseconds (+/- 2927.1 years of duration)

pub fn from_f64(value: f64, unit: Unit) -> Duration

Creates a new duration from the provided unit

pub fn in_seconds(&self) -> f64

Returns this duration in seconds f64. For high fidelity comparisons, it is recommended to keep using the Duration structure.

pub fn in_unit(&self, unit: Unit) -> f64

Returns the value of this duration in the requested unit.

pub fn abs(&self) -> Duration

Returns the absolute value of this duration

pub fn new(centuries: i16, nanoseconds: u64) -> Duration

Builds a new duration from the number of centuries and the number of nanoseconds

pub const fn signum(&self) -> i8

Returns the sign of this duration

pub fn decompose(&self) -> (i8, u64, u64, u64, u64, u64, u64, u64)

Decomposes a Duration in its sign, days, hours, minutes, seconds, ms, us, ns

pub fn compose( sign: i8, days: u64, hours: u64, minutes: u64, seconds: u64, milliseconds: u64, microseconds: u64, nanoseconds: u64 ) -> Duration

Creates a new duration from its parts

pub fn floor(&self, duration: Duration) -> Duration

Floors this duration to the closest duration from the bottom

Example

use hifitime::{Duration, TimeUnits};

let two_hours_three_min = 2.hours() + 3.minutes();
assert_eq!(two_hours_three_min.floor(1.hours()), 2.hours());
assert_eq!(two_hours_three_min.floor(30.minutes()), 2.hours());
// This is zero because we floor by a duration longer than the current duration, rounding it down
assert_eq!(two_hours_three_min.floor(4.hours()), 0.hours());
assert_eq!(two_hours_three_min.floor(1.seconds()), two_hours_three_min);
assert_eq!(two_hours_three_min.floor(1.hours() + 1.minutes()), 2.hours() + 2.minutes());
assert_eq!(two_hours_three_min.floor(1.hours() + 5.minutes()), 1.hours() + 5.minutes());

pub fn ceil(&self, duration: Duration) -> Duration

Ceils this duration to the closest provided duration

This simply floors then adds the requested duration

Example

use hifitime::{Duration, TimeUnits};

let two_hours_three_min = 2.hours() + 3.minutes();
assert_eq!(two_hours_three_min.ceil(1.hours()), 3.hours());
assert_eq!(two_hours_three_min.ceil(30.minutes()), 2.hours() + 30.minutes());
assert_eq!(two_hours_three_min.ceil(4.hours()), 4.hours());
assert_eq!(two_hours_three_min.ceil(1.seconds()), two_hours_three_min + 1.seconds());
assert_eq!(two_hours_three_min.ceil(1.hours() + 5.minutes()), 2.hours() + 10.minutes());

pub fn round(&self, duration: Duration) -> Duration

Rounds this duration to the closest provided duration

This performs both a ceil and floor and returns the value which is the closest to current one.

Example

use hifitime::{Duration, TimeUnits};

let two_hours_three_min = 2.hours() + 3.minutes();
assert_eq!(two_hours_three_min.round(1.hours()), 2.hours());
assert_eq!(two_hours_three_min.round(30.minutes()), 2.hours());
assert_eq!(two_hours_three_min.round(4.hours()), 4.hours());
assert_eq!(two_hours_three_min.round(1.seconds()), two_hours_three_min);
assert_eq!(two_hours_three_min.round(1.hours() + 5.minutes()), 2.hours() + 10.minutes());

pub const ZERO: Duration = Self{ centuries: 0, nanoseconds: 0,}

A duration of exactly zero nanoseconds

pub const MAX: Duration = Self{ centuries: i16::MAX, nanoseconds: NANOSECONDS_PER_CENTURY,}

Maximum duration that can be represented

pub const MIN: Duration = Self{ centuries: i16::MIN, nanoseconds: NANOSECONDS_PER_CENTURY,}

Minimum duration that can be represented

pub const EPSILON: Duration = Self{ centuries: 0, nanoseconds: 1,}

Smallest duration that can be represented

pub const MIN_POSITIVE: Duration = Self::EPSILON

Minimum positive duration is one nanoseconds

pub const MIN_NEGATIVE: Duration = Self{ centuries: -1, nanoseconds: NANOSECONDS_PER_CENTURY - 1,}

Minimum negative duration is minus one nanosecond

Trait Implementations

impl Add<Duration> for Duration

type Output = Duration

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Duration> for Epoch

type Output = Epoch

The resulting type after applying the + operator.

fn add(self, duration: Duration) -> Epoch

Performs the + operation.

impl Add<Unit> for Duration

type Output = Duration

The resulting type after applying the + operator.

fn add(self, rhs: Unit) -> Duration

Performs the + operation.

impl AddAssign<Duration> for Duration

fn add_assign(&mut self, rhs: Duration)

Performs the += operation.

impl AddAssign<Duration> for Epoch

fn add_assign(&mut self, duration: Duration)

Performs the += operation.

impl AddAssign<Unit> for Duration

fn add_assign(&mut self, rhs: Unit)

Performs the += operation.

impl Clone for Duration

fn clone(&self) -> Duration

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Duration

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Duration

fn deserialize<D>( deserializer: D ) -> Result<Duration, <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Duration

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

Formats the value using the given formatter.

impl Div<f64> for Duration

type Output = Duration

The resulting type after applying the / operator.

fn div(self, q: f64) -> <Duration as Div<f64>>::Output

Performs the / operation.

impl Div<i64> for Duration

type Output = Duration

The resulting type after applying the / operator.

fn div(self, q: i64) -> <Duration as Div<i64>>::Output

Performs the / operation.

impl FromStr for Duration

fn from_str(s: &str) -> Result<Duration, <Duration as FromStr>::Err>

Attempts to convert a simple string to a Duration. Does not yet support complicated durations.

Identifiers:

• d, days, day
• h, hours, hour
• min, mins, minute
• s, second, seconds
• ms, millisecond, milliseconds
• us, microsecond, microseconds
• ns, nanosecond, nanoseconds

Example

use hifitime::{Duration, Unit};
use std::str::FromStr;

assert_eq!(Duration::from_str("1 d").unwrap(), Unit::Day * 1);
assert_eq!(Duration::from_str("10.598 days").unwrap(), Unit::Day * 10.598);
assert_eq!(Duration::from_str("10.598 min").unwrap(), Unit::Minute * 10.598);
assert_eq!(Duration::from_str("10.598 us").unwrap(), Unit::Microsecond * 10.598);
assert_eq!(Duration::from_str("10.598 seconds").unwrap(), Unit::Second * 10.598);
assert_eq!(Duration::from_str("10.598 nanosecond").unwrap(), Unit::Nanosecond * 10.598);

type Err = Errors

The associated error which can be returned from parsing.

impl LowerExp for Duration

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

Formats the value using the given formatter.

impl Mul<f64> for Duration

type Output = Duration

The resulting type after applying the * operator.

fn mul(self, q: f64) -> <Duration as Mul<f64>>::Output

Performs the * operation.

impl Mul<i64> for Duration

type Output = Duration

The resulting type after applying the * operator.

fn mul(self, q: i64) -> <Duration as Mul<i64>>::Output

Performs the * operation.

impl Neg for Duration

type Output = Duration

The resulting type after applying the - operator.

fn neg(self) -> <Duration as Neg>::Output

Performs the unary - operation.

impl Ord for Duration

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

fn eq(&self, other: &Duration) -> 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 PartialEq<Unit> for Duration

fn eq(&self, unit: &Unit) -> 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<Duration> for Duration

fn partial_cmp(&self, other: &Duration) -> 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 PartialOrd<Unit> for Duration

fn partial_cmp(&self, unit: &Unit) -> 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 Duration

type Output = Duration

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Duration> for Epoch

type Output = Epoch

The resulting type after applying the - operator.

fn sub(self, duration: Duration) -> Epoch

Performs the - operation.

impl Sub<Unit> for Duration

type Output = Duration

The resulting type after applying the - operator.

fn sub(self, rhs: Unit) -> Duration

Performs the - operation.

impl SubAssign<Duration> for Duration

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation.

impl SubAssign<Duration> for Epoch

fn sub_assign(&mut self, duration: Duration)

Performs the -= operation.

impl SubAssign<Unit> for Duration

fn sub_assign(&mut self, rhs: Unit)

Performs the -= operation.

impl Copy for Duration

impl Eq for Duration

impl StructuralEq for Duration