Struct time::Duration

pub struct Duration { /* fields omitted */ }

A span of time with nanosecond precision.

Each Duration is composed of a whole number of seconds and a fractional part represented in nanoseconds.

Duration implements many traits, including Add, Sub, Mul, and Div, among others.

This implementation allows for negative durations, unlike core::time::Duration.

Implementations

impl Duration

pub const fn zero() -> Self

Equivalent to 0.seconds().

assert_eq!(Duration::zero(), 0.seconds());

pub const fn nanosecond() -> Self

Equivalent to 1.nanoseconds().

assert_eq!(Duration::nanosecond(), 1.nanoseconds());

pub const fn microsecond() -> Self

Equivalent to 1.microseconds().

assert_eq!(Duration::microsecond(), 1.microseconds());

pub const fn millisecond() -> Self

Equivalent to 1.milliseconds().

assert_eq!(Duration::millisecond(), 1.milliseconds());

pub const fn second() -> Self

Equivalent to 1.seconds().

assert_eq!(Duration::second(), 1.seconds());

pub const fn minute() -> Self

Equivalent to 1.minutes().

assert_eq!(Duration::minute(), 1.minutes());

pub const fn hour() -> Self

Equivalent to 1.hours().

assert_eq!(Duration::hour(), 1.hours());

pub const fn day() -> Self

Equivalent to 1.days().

assert_eq!(Duration::day(), 1.days());

pub const fn week() -> Self

Equivalent to 1.weeks().

assert_eq!(Duration::week(), 1.weeks());

pub const fn max_value() -> Self

The maximum possible duration. Adding any positive duration to this will cause an overflow.

The value returned by this method may change at any time.

pub const fn min_value() -> Self

The minimum possible duration. Adding any negative duration to this will cause an overflow.

The value returned by this method may change at any time.

pub const fn is_zero(self) -> bool

Check if a duration is exactly zero.

assert!(0.seconds().is_zero());
assert!(!1.nanoseconds().is_zero());

pub const fn is_negative(self) -> bool

Check if a duration is negative.

assert!((-1).seconds().is_negative());
assert!(!0.seconds().is_negative());
assert!(!1.seconds().is_negative());

pub const fn is_positive(self) -> bool

Check if a duration is positive.

assert!(1.seconds().is_positive());
assert!(!0.seconds().is_positive());
assert!(!(-1).seconds().is_positive());

pub fn sign(self) -> Sign

👎 Deprecated since 0.2.7:

To obtain the sign of a Duration, you should use the is_positive, is_negative, and is_zero methods.

Get the sign of the duration.

assert_eq!(1.seconds().sign(), Sign::Positive);
assert_eq!((-1).seconds().sign(), Sign::Negative);
assert_eq!(0.seconds().sign(), Sign::Zero);

pub const fn abs(self) -> Self

Get the absolute value of the duration.

assert_eq!(1.seconds().abs(), 1.seconds());
assert_eq!(0.seconds().abs(), 0.seconds());
assert_eq!((-1).seconds().abs(), 1.seconds());

This function is const fn when using rustc >= 1.39.

pub const fn new(seconds: i64, nanoseconds: i32) -> Self

Create a new Duration with the provided seconds and nanoseconds. If nanoseconds is at least ±10⁹, it will wrap to the number of seconds.

assert_eq!(Duration::new(1, 0), 1.seconds());
assert_eq!(Duration::new(-1, 0), (-1).seconds());
assert_eq!(Duration::new(1, 2_000_000_000), 3.seconds());

pub const fn weeks(weeks: i64) -> Self

Create a new Duration with the given number of weeks. Equivalent to Duration::seconds(weeks * 604_800).

assert_eq!(Duration::weeks(1), 604_800.seconds());

pub const fn whole_weeks(self) -> i64

Get the number of whole weeks in the duration.

assert_eq!(1.weeks().whole_weeks(), 1);
assert_eq!((-1).weeks().whole_weeks(), -1);
assert_eq!(6.days().whole_weeks(), 0);
assert_eq!((-6).days().whole_weeks(), 0);

pub const fn days(days: i64) -> Self

Create a new Duration with the given number of days. Equivalent to Duration::seconds(days * 86_400).

assert_eq!(Duration::days(1), 86_400.seconds());

pub const fn whole_days(self) -> i64

Get the number of whole days in the duration.

assert_eq!(1.days().whole_days(), 1);
assert_eq!((-1).days().whole_days(), -1);
assert_eq!(23.hours().whole_days(), 0);
assert_eq!((-23).hours().whole_days(), 0);

pub const fn hours(hours: i64) -> Self

Create a new Duration with the given number of hours. Equivalent to Duration::seconds(hours * 3_600).

assert_eq!(Duration::hours(1), 3_600.seconds());

pub const fn whole_hours(self) -> i64

Get the number of whole hours in the duration.

assert_eq!(1.hours().whole_hours(), 1);
assert_eq!((-1).hours().whole_hours(), -1);
assert_eq!(59.minutes().whole_hours(), 0);
assert_eq!((-59).minutes().whole_hours(), 0);

pub const fn minutes(minutes: i64) -> Self

Create a new Duration with the given number of minutes. Equivalent to Duration::seconds(minutes * 60).

assert_eq!(Duration::minutes(1), 60.seconds());

pub const fn whole_minutes(self) -> i64

Get the number of whole minutes in the duration.

assert_eq!(1.minutes().whole_minutes(), 1);
assert_eq!((-1).minutes().whole_minutes(), -1);
assert_eq!(59.seconds().whole_minutes(), 0);
assert_eq!((-59).seconds().whole_minutes(), 0);

pub const fn seconds(seconds: i64) -> Self

Create a new Duration with the given number of seconds.

assert_eq!(Duration::seconds(1), 1_000.milliseconds());

pub const fn whole_seconds(self) -> i64

Get the number of whole seconds in the duration.

assert_eq!(1.seconds().whole_seconds(), 1);
assert_eq!((-1).seconds().whole_seconds(), -1);
assert_eq!(1.minutes().whole_seconds(), 60);
assert_eq!((-1).minutes().whole_seconds(), -60);

pub fn seconds_f64(seconds: f64) -> Self

Creates a new Duration from the specified number of seconds represented as f64.

assert_eq!(Duration::seconds_f64(0.5), 0.5.seconds());
assert_eq!(Duration::seconds_f64(-0.5), -0.5.seconds());

pub fn as_seconds_f64(self) -> f64

Get the number of fractional seconds in the duration.

assert_eq!(1.5.seconds().as_seconds_f64(), 1.5);
assert_eq!((-1.5).seconds().as_seconds_f64(), -1.5);

pub fn seconds_f32(seconds: f32) -> Self

Creates a new Duration from the specified number of seconds represented as f32.

assert_eq!(Duration::seconds_f32(0.5), 0.5.seconds());
assert_eq!(Duration::seconds_f32(-0.5), (-0.5).seconds());

pub fn as_seconds_f32(self) -> f32

Get the number of fractional seconds in the duration.

assert_eq!(1.5.seconds().as_seconds_f32(), 1.5);
assert_eq!((-1.5).seconds().as_seconds_f32(), -1.5);

pub const fn milliseconds(milliseconds: i64) -> Self

Create a new Duration with the given number of milliseconds.

assert_eq!(Duration::milliseconds(1), 1_000.microseconds());
assert_eq!(Duration::milliseconds(-1), (-1_000).microseconds());

pub const fn whole_milliseconds(self) -> i128

Get the number of whole milliseconds in the duration.

assert_eq!(1.seconds().whole_milliseconds(), 1_000);
assert_eq!((-1).seconds().whole_milliseconds(), -1_000);
assert_eq!(1.milliseconds().whole_milliseconds(), 1);
assert_eq!((-1).milliseconds().whole_milliseconds(), -1);

pub const fn subsec_milliseconds(self) -> i16

Get the number of milliseconds past the number of whole seconds.

Always in the range -1_000..1_000.

assert_eq!(1.4.seconds().subsec_milliseconds(), 400);
assert_eq!((-1.4).seconds().subsec_milliseconds(), -400);

pub const fn microseconds(microseconds: i64) -> Self

Create a new Duration with the given number of microseconds.

assert_eq!(Duration::microseconds(1), 1_000.nanoseconds());
assert_eq!(Duration::microseconds(-1), (-1_000).nanoseconds());

pub const fn whole_microseconds(self) -> i128

Get the number of whole microseconds in the duration.

assert_eq!(1.milliseconds().whole_microseconds(), 1_000);
assert_eq!((-1).milliseconds().whole_microseconds(), -1_000);
assert_eq!(1.microseconds().whole_microseconds(), 1);
assert_eq!((-1).microseconds().whole_microseconds(), -1);

pub const fn subsec_microseconds(self) -> i32

Get the number of microseconds past the number of whole seconds.

Always in the range -1_000_000..1_000_000.

assert_eq!(1.0004.seconds().subsec_microseconds(), 400);
assert_eq!((-1.0004).seconds().subsec_microseconds(), -400);

pub const fn nanoseconds(nanoseconds: i64) -> Self

Create a new Duration with the given number of nanoseconds.

assert_eq!(Duration::nanoseconds(1), 1.microseconds() / 1_000);
assert_eq!(Duration::nanoseconds(-1), (-1).microseconds() / 1_000);

pub const fn whole_nanoseconds(self) -> i128

Get the number of nanoseconds in the duration.

assert_eq!(1.microseconds().whole_nanoseconds(), 1_000);
assert_eq!((-1).microseconds().whole_nanoseconds(), -1_000);
assert_eq!(1.nanoseconds().whole_nanoseconds(), 1);
assert_eq!((-1).nanoseconds().whole_nanoseconds(), -1);

pub const fn subsec_nanoseconds(self) -> i32

Get the number of nanoseconds past the number of whole seconds.

The returned value will always be in the range -1_000_000_000..1_000_000_000.

assert_eq!(1.000_000_400.seconds().subsec_nanoseconds(), 400);
assert_eq!((-1.000_000_400).seconds().subsec_nanoseconds(), -400);

pub fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if an overflow occurred.

assert_eq!(5.seconds().checked_add(5.seconds()), Some(10.seconds()));
assert_eq!(Duration::max_value().checked_add(1.nanoseconds()), None);
assert_eq!((-5).seconds().checked_add(5.seconds()), Some(0.seconds()));

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if an overflow occurred.

assert_eq!(5.seconds().checked_sub(5.seconds()), Some(Duration::zero()));
assert_eq!(Duration::min_value().checked_sub(1.nanoseconds()), None);
assert_eq!(5.seconds().checked_sub(10.seconds()), Some((-5).seconds()));

pub fn checked_mul(self, rhs: i32) -> Option<Self>

Computes self * rhs, returning None if an overflow occurred.

assert_eq!(5.seconds().checked_mul(2), Some(10.seconds()));
assert_eq!(5.seconds().checked_mul(-2), Some((-10).seconds()));
assert_eq!(5.seconds().checked_mul(0), Some(0.seconds()));
assert_eq!(Duration::max_value().checked_mul(2), None);
assert_eq!(Duration::min_value().checked_mul(2), None);

pub const fn checked_div(self, rhs: i32) -> Option<Self>

Computes self / rhs, returning None if rhs == 0.

assert_eq!(10.seconds().checked_div(2), Some(5.seconds()));
assert_eq!(10.seconds().checked_div(-2), Some((-5).seconds()));
assert_eq!(1.seconds().checked_div(0), None);

This function is const fn when using rustc >= 1.46.

pub fn time_fn<T>(f: impl FnOnce() -> T) -> (Self, T)

Runs a closure, returning the duration of time it took to run. The return value of the closure is provided in the second part of the tuple.

impl Duration

Functions that have been renamed or had signatures changed since v0.1. As such, they are deprecated.

pub fn num_weeks(&self) -> i64

👎 Deprecated since 0.2.0:

Use the whole_weeks function

pub fn num_days(&self) -> i64

👎 Deprecated since 0.2.0:

Use the whole_days function

pub fn num_hours(&self) -> i64

👎 Deprecated since 0.2.0:

Use the whole_hours function

pub fn num_minutes(&self) -> i64

👎 Deprecated since 0.2.0:

Use the whole_minutes function

pub fn num_seconds(&self) -> i64

👎 Deprecated since 0.2.0:

Use the whole_seconds function

pub fn num_milliseconds(&self) -> i64

👎 Deprecated since 0.2.0:

Use the whole_milliseconds function. The value is clamped between i64::min_value() and i64::max_value().

Duration::whole_milliseconds returns an i128, rather than panicking on overflow. To avoid panicking, this method currently limits the value to the range i64::min_value()..=i64::max_value().

pub fn num_microseconds(&self) -> Option<i64>

👎 Deprecated since 0.2.0:

Use the whole_microseconds function

Duration::whole_microseconds returns an i128 rather than returning None on i64 overflow.

pub fn num_nanoseconds(&self) -> Option<i64>

👎 Deprecated since 0.2.0:

Use the whole_nanoseconds function

Duration::whole_nanoseconds returns an i128 rather than returning None on i64 overflow.

pub fn span<F: FnOnce()>(f: F) -> Self

👎 Deprecated since 0.2.0:

Use the time_fn function

pub fn from_std(std: StdDuration) -> Result<Self, ConversionRange>

👎 Deprecated since 0.2.0:

Use Duration::try_from(value) or value.try_into()

pub fn to_std(&self) -> Result<StdDuration, ConversionRange>

👎 Deprecated since 0.2.0:

Use std::time::Duration::try_from(value) or value.try_into()

Trait Implementations

impl Add<Duration> for Date

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Duration> for Duration

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Duration> for Duration

type Output = Self

The resulting type after applying the + operator.

fn add(self, std_duration: StdDuration) -> Self::Output

Performs the + operation.

impl Add<Duration> for StdDuration

type Output = Duration

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Duration> for Instant

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Duration> for StdInstant

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Duration> for OffsetDateTime

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Duration> for SystemTime

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Duration> for PrimitiveDateTime

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Duration> for Time

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

Add the sub-day time of the Duration to the Time. Wraps on overflow.

assert_eq!(time!(12:00) + 2.hours(), time!(14:00));
assert_eq!(time!(0:00:01) + (-2).seconds(), time!(23:59:59));

type Output = Self

The resulting type after applying the + operator.

impl AddAssign<Duration> for Date

fn add_assign(&mut self, duration: Duration)

Performs the += operation.

impl AddAssign<Duration> for Duration

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl AddAssign<Duration> for Duration

fn add_assign(&mut self, rhs: StdDuration)

Performs the += operation.

impl AddAssign<Duration> for Instant

fn add_assign(&mut self, duration: Duration)

Performs the += operation.

impl AddAssign<Duration> for StdInstant

fn add_assign(&mut self, duration: Duration)

Performs the += operation.

impl AddAssign<Duration> for OffsetDateTime

fn add_assign(&mut self, duration: Duration)

Performs the += operation.

impl AddAssign<Duration> for SystemTime

fn add_assign(&mut self, duration: Duration)

Performs the += operation.

impl AddAssign<Duration> for PrimitiveDateTime

fn add_assign(&mut self, duration: Duration)

Performs the += operation.

impl AddAssign<Duration> for Time

fn add_assign(&mut self, duration: Duration)

Add the sub-day time of the Duration to the existing Time. Wraps on overflow.

let mut time = time!(12:00);
time += 2.hours();
assert_eq!(time, time!(14:00));

let mut time = time!(0:00:01);
time += (-2).seconds();
assert_eq!(time, time!(23:59:59));

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

Formats the value using the given formatter.

impl Default for Duration

fn default() -> Duration

Returns the “default value” for a type.

impl Div<Duration> for Duration

type Output = f64

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl Div<Duration> for Duration

type Output = f64

The resulting type after applying the / operator.

fn div(self, rhs: StdDuration) -> Self::Output

Performs the / operation.

impl Div<Duration> for StdDuration

type Output = f64

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f32> for Duration

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl Div<f64> for Duration

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl Div<i16> for Duration

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Self::Output

Performs the / operation.

impl Div<i32> for Duration

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl Div<i8> for Duration

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Self::Output

Performs the / operation.

impl Div<u16> for Duration

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Self::Output

Performs the / operation.

impl Div<u32> for Duration

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl Div<u8> for Duration

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Self::Output

Performs the / operation.

impl DivAssign<f32> for Duration

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl DivAssign<f64> for Duration

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

impl DivAssign<i16> for Duration

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl DivAssign<i32> for Duration

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl DivAssign<i8> for Duration

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl DivAssign<u16> for Duration

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl DivAssign<u32> for Duration

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl DivAssign<u8> for Duration

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl Hash for Duration

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, 

Feeds a slice of this type into the given Hasher.

impl Mul<Duration> for i8

type Output = Duration

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Duration> for i16

type Output = Duration

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Duration> for i32

type Output = Duration

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Duration> for u8

type Output = Duration

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Duration> for u16

type Output = Duration

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Duration> for u32

type Output = Duration

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Duration> for f32

type Output = Duration

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Duration> for f64

type Output = Duration

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for Duration

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl Mul<f64> for Duration

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl Mul<i16> for Duration

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Self::Output

Performs the * operation.

impl Mul<i32> for Duration

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl Mul<i8> for Duration

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl Mul<u16> for Duration

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation.

impl Mul<u32> for Duration

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl Mul<u8> for Duration

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation.

impl MulAssign<f32> for Duration

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl MulAssign<f64> for Duration

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl MulAssign<i16> for Duration

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl MulAssign<i32> for Duration

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl MulAssign<i8> for Duration

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl MulAssign<u16> for Duration

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl MulAssign<u32> for Duration

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl MulAssign<u8> for Duration

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl Neg for Duration

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for Duration

fn cmp(&self, rhs: &Self) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> 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: &Duration) -> bool

This method tests for !=.

impl PartialEq<Duration> for Duration

fn eq(&self, rhs: &StdDuration) -> 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 !=.

impl PartialEq<Duration> for StdDuration

fn eq(&self, rhs: &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 !=.

impl PartialOrd<Duration> for Duration

fn partial_cmp(&self, rhs: &Self) -> 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<Duration> for Duration

fn partial_cmp(&self, rhs: &StdDuration) -> 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<Duration> for StdDuration

fn partial_cmp(&self, rhs: &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 Sub<Duration> for Date

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Duration> for Duration

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Duration> for Duration

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Duration> for StdDuration

type Output = Duration

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Duration> for Instant

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Duration> for StdInstant

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Duration> for OffsetDateTime

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Duration> for SystemTime

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Duration> for PrimitiveDateTime

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Duration> for Time

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

Subtract the sub-day time of the Duration from the Time. Wraps on overflow.

assert_eq!(
    time!(14:00) - 2.hours(),
    time!(12:00)
);
assert_eq!(
    time!(23:59:59) - (-2).seconds(),
    time!(0:00:01)
);

type Output = Self

The resulting type after applying the - operator.

impl SubAssign<Duration> for Date

fn sub_assign(&mut self, duration: Duration)

Performs the -= operation.

impl SubAssign<Duration> for Duration

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl SubAssign<Duration> for Duration

fn sub_assign(&mut self, rhs: StdDuration)

Performs the -= operation.

impl SubAssign<Duration> for StdDuration

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation.

impl SubAssign<Duration> for Instant

fn sub_assign(&mut self, duration: Duration)

Performs the -= operation.

impl SubAssign<Duration> for StdInstant

fn sub_assign(&mut self, duration: Duration)

Performs the -= operation.

impl SubAssign<Duration> for OffsetDateTime

fn sub_assign(&mut self, duration: Duration)

Performs the -= operation.

impl SubAssign<Duration> for SystemTime

fn sub_assign(&mut self, duration: Duration)

Performs the -= operation.

impl SubAssign<Duration> for PrimitiveDateTime

fn sub_assign(&mut self, duration: Duration)

Performs the -= operation.

impl SubAssign<Duration> for Time

fn sub_assign(&mut self, duration: Duration)

Subtract the sub-day time of the Duration from the existing Time. Wraps on overflow.

let mut time = time!(14:00);
time -= 2.hours();
assert_eq!(time, time!(12:00));

let mut time = time!(23:59:59);
time -= (-2).seconds();
assert_eq!(time, time!(0:00:01));

impl TryFrom<Duration> for Duration

type Error = ConversionRange

The type returned in the event of a conversion error.

fn try_from(original: StdDuration) -> Result<Self, ConversionRange>

Performs the conversion.

impl TryFrom<Duration> for StdDuration

type Error = ConversionRange

The type returned in the event of a conversion error.

fn try_from(duration: Duration) -> Result<Self, ConversionRange>

Performs the conversion.

impl Copy for Duration

impl Eq for Duration

impl StructuralEq for Duration

impl StructuralPartialEq for Duration