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.

Methods

impl Duration

pub const fn zero() -> Self

Equivalent to Duration::seconds(0).

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

pub const fn nanosecond() -> Self

Equivalent to Duration::nanoseconds(1).

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

pub const fn microsecond() -> Self

Equivalent to Duration::microseconds(1).

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

pub const fn millisecond() -> Self

Equivalent to Duration::milliseconds(1).

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

pub const fn second() -> Self

Equivalent to Duration::seconds(1).

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

pub const fn minute() -> Self

Equivalent to Duration::minutes(1).

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

pub const fn hour() -> Self

Equivalent to Duration::hours(1).

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

pub const fn day() -> Self

Equivalent to Duration::days(1).

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

pub const fn week() -> Self

Equivalent to Duration::weeks(1).

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

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!(Duration::seconds(0).is_zero());
assert!(!Duration::nanoseconds(1).is_zero());

pub const fn is_negative(self) -> bool

Check if a duration is negative.

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

pub const fn is_positive(self) -> bool

Check if a duration is positive.

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

pub fn sign(self) -> Sign

Get the sign of the duration.

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

pub const fn abs(self) -> Self

Get the absolute value of the duration.

assert_eq!(Duration::seconds(1).abs(), Duration::seconds(1));
assert_eq!(Duration::zero().abs(), Duration::zero());
assert_eq!(Duration::seconds(-1).abs(), Duration::seconds(1));

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), Duration::seconds(1));
assert_eq!(Duration::new(-1, 0), Duration::seconds(-1));
assert_eq!(Duration::new(1, 2_000_000_000), Duration::seconds(3));

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), Duration::seconds(604_800));

pub const fn whole_weeks(self) -> i64

Get the number of whole weeks in the duration.

assert_eq!(Duration::weeks(1).whole_weeks(), 1);
assert_eq!(Duration::weeks(-1).whole_weeks(), -1);
assert_eq!(Duration::days(6).whole_weeks(), 0);
assert_eq!(Duration::days(-6).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), Duration::seconds(86_400));

pub const fn whole_days(self) -> i64

Get the number of whole days in the duration.

assert_eq!(Duration::days(1).whole_days(), 1);
assert_eq!(Duration::days(-1).whole_days(), -1);
assert_eq!(Duration::hours(23).whole_days(), 0);
assert_eq!(Duration::hours(-23).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), Duration::seconds(3_600));

pub const fn whole_hours(self) -> i64

Get the number of whole hours in the duration.

assert_eq!(Duration::hours(1).whole_hours(), 1);
assert_eq!(Duration::hours(-1).whole_hours(), -1);
assert_eq!(Duration::minutes(59).whole_hours(), 0);
assert_eq!(Duration::minutes(-59).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), Duration::seconds(60));

pub const fn whole_minutes(self) -> i64

Get the number of whole minutes in the duration.

assert_eq!(Duration::minutes(1).whole_minutes(), 1);
assert_eq!(Duration::minutes(-1).whole_minutes(), -1);
assert_eq!(Duration::seconds(59).whole_minutes(), 0);
assert_eq!(Duration::seconds(-59).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), Duration::milliseconds(1_000));

pub const fn whole_seconds(self) -> i64

Get the number of whole seconds in the duration.

assert_eq!(Duration::seconds(1).whole_seconds(), 1);
assert_eq!(Duration::seconds(-1).whole_seconds(), -1);
assert_eq!(Duration::minutes(1).whole_seconds(), 60);
assert_eq!(Duration::minutes(-1).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), Duration::milliseconds(500));
assert_eq!(Duration::seconds_f64(-0.5), Duration::milliseconds(-500));

pub fn as_seconds_f64(self) -> f64

Get the number of fractional seconds in the duration.

assert_eq!(Duration::milliseconds(1_500).as_seconds_f64(), 1.5);
assert_eq!(Duration::milliseconds(-1_500).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), Duration::milliseconds(500));
assert_eq!(Duration::seconds_f32(-0.5), Duration::milliseconds(-500));

pub fn as_seconds_f32(self) -> f32

Get the number of fractional seconds in the duration.

assert_eq!(Duration::milliseconds(1_500).as_seconds_f32(), 1.5);
assert_eq!(Duration::milliseconds(-1_500).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), Duration::seconds(1) / 1_000);
assert_eq!(Duration::milliseconds(-1), Duration::seconds(-1) / 1_000);

pub const fn whole_milliseconds(self) -> i128

Get the number of whole milliseconds in the duration.

assert_eq!(Duration::seconds(1).whole_milliseconds(), 1_000);
assert_eq!(Duration::seconds(-1).whole_milliseconds(), -1_000);
assert_eq!(Duration::milliseconds(1).whole_milliseconds(), 1);
assert_eq!(Duration::milliseconds(-1).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 0..1_000.

assert_eq!(Duration::milliseconds(1_400).subsec_milliseconds(), 400);
assert_eq!(Duration::milliseconds(-1_400).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), Duration::seconds(1) / 1_000_000);
assert_eq!(
    Duration::microseconds(-1),
    Duration::seconds(-1) / 1_000_000
);

pub const fn whole_microseconds(self) -> i128

Get the number of whole microseconds in the duration.

assert_eq!(Duration::milliseconds(1).whole_microseconds(), 1_000);
assert_eq!(Duration::milliseconds(-1).whole_microseconds(), -1_000);
assert_eq!(Duration::microseconds(1).whole_microseconds(), 1);
assert_eq!(Duration::microseconds(-1).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 0..1_000_000.

assert_eq!(Duration::microseconds(1_000_400).subsec_microseconds(), 400);
assert_eq!(
    Duration::microseconds(-1_000_400).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),
    Duration::seconds(1) / 1_000_000_000
);
assert_eq!(
    Duration::nanoseconds(-1),
    Duration::seconds(-1) / 1_000_000_000
);

pub const fn whole_nanoseconds(self) -> i128

Get the number of nanoseconds in the duration.

assert_eq!(Duration::microseconds(1).whole_nanoseconds(), 1_000);
assert_eq!(Duration::microseconds(-1).whole_nanoseconds(), -1_000);
assert_eq!(Duration::nanoseconds(1).whole_nanoseconds(), 1);
assert_eq!(Duration::nanoseconds(-1).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 0..1_000_000_000.

assert_eq!(
    Duration::nanoseconds(1_000_000_400).subsec_nanoseconds(),
    400
);
assert_eq!(
    Duration::nanoseconds(-1_000_000_400).subsec_nanoseconds(),
    -400
);

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

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

assert_eq!(
    Duration::seconds(5).checked_add(Duration::seconds(5)),
    Some(Duration::seconds(10))
);
assert_eq!(
    Duration::max_value().checked_add(Duration::nanosecond()),
    None
);
assert_eq!(
    Duration::seconds(-5).checked_add(Duration::seconds(5)),
    Some(Duration::zero())
);

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

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

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

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

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

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

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

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

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

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

This is supported on feature="std" only.

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, ConversionRangeError>

Deprecated since 0.2.0:

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

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

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, duration: 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 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 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 Time

type Output = Self

The resulting type after applying the + operator.

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) + Duration::hours(2),
    time!(14:00)
);
assert_eq!(
    time!(0:00:01) + Duration::seconds(-2),
    time!(23:59:59)
);

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 PrimitiveDateTime

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 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 += Duration::hours(2);
assert_eq!(time, time!(14:00));

let mut time = time!(0:00:01);
time += Duration::seconds(-2);
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 Copy for Duration

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<'de> Deserialize<'de> for Duration

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

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 Eq for Duration

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

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

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 ==.

#[must_use] 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 ==.

#[must_use] 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.

#[must_use] fn lt(&self, other: &Rhs) -> bool

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

#[must_use] fn le(&self, other: &Rhs) -> bool

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

#[must_use] fn gt(&self, other: &Rhs) -> bool

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

#[must_use] 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.

#[must_use] fn lt(&self, other: &Rhs) -> bool

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

#[must_use] fn le(&self, other: &Rhs) -> bool

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

#[must_use] fn gt(&self, other: &Rhs) -> bool

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

#[must_use] 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.

#[must_use] fn lt(&self, other: &Rhs) -> bool

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

#[must_use] fn le(&self, other: &Rhs) -> bool

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

#[must_use] fn gt(&self, other: &Rhs) -> bool

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

#[must_use] 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 Serialize for Duration

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralEq for Duration

impl StructuralPartialEq for Duration

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

type Output = Self

The resulting type after applying the - operator.

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) - Duration::hours(2),
    time!(12:00)
);
assert_eq!(
    time!(23:59:59) - Duration::seconds(-2),
    time!(0:00:01)
);

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 PrimitiveDateTime

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 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 -= Duration::hours(2);
assert_eq!(time, time!(12:00));

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

impl TryFrom<Duration> for Duration

type Error = ConversionRangeError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<Duration> for StdDuration

type Error = ConversionRangeError

The type returned in the event of a conversion error.

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

Performs the conversion.