Struct Duration

pub struct Duration {
    seconds: i64,
    nanoseconds: RangedI32<{ _ }, { _ }>,
    padding: Padding,
}

A span of time with nanosecond precision.

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

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

Fields

seconds: i64

Number of whole seconds.

nanoseconds: RangedI32<{ _ }, { _ }>

Number of nanoseconds within the second. The sign always matches the seconds field.

padding: Padding

Implementations

impl Duration

pub const ZERO: Self = _

Equivalent to 0.seconds().

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

pub const NANOSECOND: Self = _

Equivalent to 1.nanoseconds().

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

pub const MICROSECOND: Self = _

Equivalent to 1.microseconds().

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

pub const MILLISECOND: Self = _

Equivalent to 1.milliseconds().

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

pub const SECOND: Self = _

Equivalent to 1.seconds().

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

pub const MINUTE: Self = _

Equivalent to 1.minutes().

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

pub const HOUR: Self = _

Equivalent to 1.hours().

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

pub const DAY: Self = _

Equivalent to 1.days().

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

pub const WEEK: Self = _

Equivalent to 1.weeks().

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

pub const MIN: Self = _

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

pub const MAX: Self = _

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

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 const fn abs(self) -> Self

Get the absolute value of the duration.

This method saturates the returned value if it would otherwise overflow.

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

pub const fn unsigned_abs(self) -> StdDuration

Convert the existing Duration to a std::time::Duration and its sign. This returns a std::time::Duration and does not saturate the returned value (unlike Duration::abs).

assert_eq!(1.seconds().unsigned_abs(), 1.std_seconds());
assert_eq!(0.seconds().unsigned_abs(), 0.std_seconds());
assert_eq!((-1).seconds().unsigned_abs(), 1.std_seconds());

pub(crate) const unsafe fn new_unchecked(seconds: i64, nanoseconds: i32) -> Self

Create a new Duration without checking the validity of the components.

Safety

• nanoseconds must be in the range -999_999_999..=999_999_999.

While the sign of nanoseconds is required to be the same as the sign of seconds, this is not a safety invariant.

pub(crate) const fn new_ranged_unchecked( seconds: i64, nanoseconds: RangedI32<{ _ }, { _ }>, ) -> Self

Create a new Duration without checking the validity of the components.

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());

Panics

This may panic if an overflow occurs.

pub(crate) const fn new_ranged( seconds: i64, nanoseconds: RangedI32<{ _ }, { _ }>, ) -> Self

Create a new Duration with the provided seconds and nanoseconds.

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());

Panics

This may panic if an overflow occurs.

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());

Panics

This may panic if an overflow occurs.

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());

Panics

This may panic if an overflow occurs.

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());

Panics

This may panic if an overflow occurs.

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 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 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 saturating_seconds_f64(seconds: f64) -> Self

Creates a new Duration from the specified number of seconds represented as f64. Any values that are out of bounds are saturated at the minimum or maximum respectively. NaN gets turned into a Duration of 0 seconds.

assert_eq!(Duration::saturating_seconds_f64(0.5), 0.5.seconds());
assert_eq!(Duration::saturating_seconds_f64(-0.5), (-0.5).seconds());
assert_eq!(
    Duration::saturating_seconds_f64(f64::NAN),
    Duration::new(0, 0),
);
assert_eq!(
    Duration::saturating_seconds_f64(f64::NEG_INFINITY),
    Duration::MIN,
);
assert_eq!(
    Duration::saturating_seconds_f64(f64::INFINITY),
    Duration::MAX,
);

pub fn saturating_seconds_f32(seconds: f32) -> Self

Creates a new Duration from the specified number of seconds represented as f32. Any values that are out of bounds are saturated at the minimum or maximum respectively. NaN gets turned into a Duration of 0 seconds.

assert_eq!(Duration::saturating_seconds_f32(0.5), 0.5.seconds());
assert_eq!(Duration::saturating_seconds_f32(-0.5), (-0.5).seconds());
assert_eq!(
    Duration::saturating_seconds_f32(f32::NAN),
    Duration::new(0, 0),
);
assert_eq!(
    Duration::saturating_seconds_f32(f32::NEG_INFINITY),
    Duration::MIN,
);
assert_eq!(
    Duration::saturating_seconds_f32(f32::INFINITY),
    Duration::MAX,
);

pub fn checked_seconds_f64(seconds: f64) -> Option<Self>

Creates a new Duration from the specified number of seconds represented as f64. Returns None if the Duration can’t be represented.

assert_eq!(Duration::checked_seconds_f64(0.5), Some(0.5.seconds()));
assert_eq!(Duration::checked_seconds_f64(-0.5), Some((-0.5).seconds()));
assert_eq!(Duration::checked_seconds_f64(f64::NAN), None);
assert_eq!(Duration::checked_seconds_f64(f64::NEG_INFINITY), None);
assert_eq!(Duration::checked_seconds_f64(f64::INFINITY), None);

pub fn checked_seconds_f32(seconds: f32) -> Option<Self>

Creates a new Duration from the specified number of seconds represented as f32. Returns None if the Duration can’t be represented.

assert_eq!(Duration::checked_seconds_f32(0.5), Some(0.5.seconds()));
assert_eq!(Duration::checked_seconds_f32(-0.5), Some((-0.5).seconds()));
assert_eq!(Duration::checked_seconds_f32(f32::NAN), None);
assert_eq!(Duration::checked_seconds_f32(f32::NEG_INFINITY), None);
assert_eq!(Duration::checked_seconds_f32(f32::INFINITY), None);

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 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 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(crate) const fn nanoseconds_i128(nanoseconds: i128) -> Self

Create a new Duration with the given number of nanoseconds.

As the input range cannot be fully mapped to the output, this should only be used where it’s known to result in a valid value.

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

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

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

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

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

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

pub(crate) const fn subsec_nanoseconds_ranged(self) -> RangedI32<{ _ }, { _ }>

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

pub const 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.checked_add(1.nanoseconds()), None);
assert_eq!((-5).seconds().checked_add(5.seconds()), Some(0.seconds()));

pub const 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.checked_sub(1.nanoseconds()), None);
assert_eq!(5.seconds().checked_sub(10.seconds()), Some((-5).seconds()));

pub const 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.checked_mul(2), None);
assert_eq!(Duration::MIN.checked_mul(2), None);

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

Computes self / rhs, returning None if rhs == 0 or if the result would overflow.

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);

pub const fn checked_neg(self) -> Option<Self>

Computes -self, returning None if the result would overflow.

assert_eq!(5.seconds().checked_neg(), Some((-5).seconds()));
assert_eq!(Duration::MIN.checked_neg(), None);

pub const fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating if an overflow occurred.

assert_eq!(5.seconds().saturating_add(5.seconds()), 10.seconds());
assert_eq!(Duration::MAX.saturating_add(1.nanoseconds()), Duration::MAX);
assert_eq!(
    Duration::MIN.saturating_add((-1).nanoseconds()),
    Duration::MIN
);
assert_eq!((-5).seconds().saturating_add(5.seconds()), Duration::ZERO);

pub const fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating if an overflow occurred.

assert_eq!(5.seconds().saturating_sub(5.seconds()), Duration::ZERO);
assert_eq!(Duration::MIN.saturating_sub(1.nanoseconds()), Duration::MIN);
assert_eq!(
    Duration::MAX.saturating_sub((-1).nanoseconds()),
    Duration::MAX
);
assert_eq!(5.seconds().saturating_sub(10.seconds()), (-5).seconds());

pub const fn saturating_mul(self, rhs: i32) -> Self

Computes self * rhs, saturating if an overflow occurred.

assert_eq!(5.seconds().saturating_mul(2), 10.seconds());
assert_eq!(5.seconds().saturating_mul(-2), (-10).seconds());
assert_eq!(5.seconds().saturating_mul(0), Duration::ZERO);
assert_eq!(Duration::MAX.saturating_mul(2), Duration::MAX);
assert_eq!(Duration::MIN.saturating_mul(2), Duration::MIN);
assert_eq!(Duration::MAX.saturating_mul(-2), Duration::MIN);
assert_eq!(Duration::MIN.saturating_mul(-2), Duration::MAX);

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

👎Deprecated since 0.3.32: extremely limited use case, not intended for benchmarking

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.

Trait Implementations

impl Add<Duration> for Date

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

Panics

This may panic if an overflow occurs.

type Output = Date

The resulting type after applying the + operator.

impl Add<Duration> for Duration

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

Panics

This may panic if an overflow occurs.

type Output = Duration

The resulting type after applying the + operator.

impl Add<Duration> for Duration

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

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

Panics

This function may panic if the resulting point in time cannot be represented by the underlying data structure.

type Output = Instant

The resulting type after applying the + operator.

impl Add<Duration> for Instant

type Output = Instant

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Duration> for OffsetDateTime

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

Panics

This may panic if an overflow occurs.

type Output = OffsetDateTime

The resulting type after applying the + operator.

impl Add<Duration> for PrimitiveDateTime

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

Panics

This may panic if an overflow occurs.

type Output = PrimitiveDateTime

The resulting type after applying the + operator.

impl Add<Duration> for SystemTime

type Output = SystemTime

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

The resulting type after applying the + operator.

impl Add for Duration

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

Panics

This may panic if an overflow occurs.

type Output = Duration

The resulting type after applying the + operator.

impl AddAssign<Duration> for Date

fn add_assign(&mut self, rhs: Duration)

Performs the += operation.

impl AddAssign<Duration> for Duration

fn add_assign(&mut self, rhs: StdDuration)

Performs the += operation.

impl AddAssign<Duration> for Duration

fn add_assign(&mut self, rhs: Duration)

Panics

This may panic if the resulting addition cannot be represented.

impl AddAssign<Duration> for Instant

fn add_assign(&mut self, rhs: Duration)

Performs the += operation.

impl AddAssign<Duration> for Instant

fn add_assign(&mut self, rhs: Duration)

Performs the += operation.

impl AddAssign<Duration> for OffsetDateTime

fn add_assign(&mut self, rhs: Duration)

Panics

This may panic if an overflow occurs.

impl AddAssign<Duration> for PrimitiveDateTime

fn add_assign(&mut self, duration: Duration)

Panics

This may panic if an overflow occurs.

impl AddAssign<Duration> for SystemTime

fn add_assign(&mut self, rhs: Duration)

Performs the += operation.

impl AddAssign<Duration> for Time

fn add_assign(&mut self, rhs: Duration)

Performs the += operation.

impl AddAssign for Duration

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Arbitrary for Duration

fn arbitrary(g: &mut Gen) -> Self

Return an arbitrary value.

fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

Return an iterator of values that are smaller than itself.

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() -> Self

Returns the “default value” for a type.

impl<'a> Deserialize<'a> for Duration

fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

#[doc(hidden)] fn deserialize_in_place<D>( deserializer: D, place: &mut Self, ) -> Result<(), <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserializes a value into self from the given Deserializer.

impl Display for Duration

The format returned by this implementation is not stable and must not be relied upon.

By default this produces an exact, full-precision printout of the duration. For a concise, rounded printout instead, you can use the .N format specifier:

let duration = Duration::new(123456, 789011223);
println!("{duration:.3}");

For the purposes of this implementation, a day is exactly 24 hours and a minute is exactly 60 seconds.

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

Formats the value using the given formatter.

impl Distribution<Duration> for Standard

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Duration

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

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 Duration

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f64> for Duration

type Output = Duration

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i16> for Duration

type Output = Duration

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i32> for Duration

type Output = Duration

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i8> for Duration

type Output = Duration

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<u16> for Duration

type Output = Duration

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<u32> for Duration

type Output = Duration

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<u8> for Duration

type Output = Duration

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for Duration

type Output = f64

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> 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

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f64> for Duration

type Output = Duration

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i16> for Duration

type Output = Duration

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i32> for Duration

type Output = Duration

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i8> for Duration

type Output = Duration

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u16> for Duration

type Output = Duration

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u32> for Duration

type Output = Duration

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u8> for Duration

type Output = Duration

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

The resulting type after applying the - operator.

fn neg(self) -> Self::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) -> 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.

impl PartialEq<Duration> for Duration

fn eq(&self, rhs: &StdDuration) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Duration> for Duration

fn eq(&self, rhs: &Duration) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for Duration

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

Tests for self and other values to be equal, and is used by ==.

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

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, rhs: &StdDuration) -> 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 PartialOrd<Duration> for Duration

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

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

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

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Sub<Duration> for Date

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

Panics

This may panic if an overflow occurs.

type Output = Date

The resulting type after applying the - operator.

impl Sub<Duration> for Duration

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

Panics

This may panic if an overflow occurs.

type Output = Duration

The resulting type after applying the - operator.

impl Sub<Duration> for Duration

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

Panics

This may panic if an overflow occurs.

type Output = Duration

The resulting type after applying the - operator.

impl Sub<Duration> for Instant

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

Panics

This function may panic if the resulting point in time cannot be represented by the underlying data structure.

type Output = Instant

The resulting type after applying the - operator.

impl Sub<Duration> for Instant

type Output = Instant

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Duration> for OffsetDateTime

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

Panics

This may panic if an overflow occurs.

type Output = OffsetDateTime

The resulting type after applying the - operator.

impl Sub<Duration> for PrimitiveDateTime

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

Panics

This may panic if an overflow occurs.

type Output = PrimitiveDateTime

The resulting type after applying the - operator.

impl Sub<Duration> for SystemTime

type Output = SystemTime

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

The resulting type after applying the - operator.

impl Sub for Duration

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

Panics

This may panic if an overflow occurs.

type Output = Duration

The resulting type after applying the - operator.

impl SubAssign<Duration> for Date

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation.

impl SubAssign<Duration> for Duration

fn sub_assign(&mut self, rhs: StdDuration)

Performs the -= operation.

impl SubAssign<Duration> for Duration

fn sub_assign(&mut self, rhs: Duration)

Panics

This may panic if the resulting subtraction can not be represented.

impl SubAssign<Duration> for Instant

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation.

impl SubAssign<Duration> for Instant

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation.

impl SubAssign<Duration> for OffsetDateTime

fn sub_assign(&mut self, rhs: Duration)

Panics

This may panic if an overflow occurs.

impl SubAssign<Duration> for PrimitiveDateTime

fn sub_assign(&mut self, duration: Duration)

Panics

This may panic if an overflow occurs.

impl SubAssign<Duration> for SystemTime

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation.

impl SubAssign<Duration> for Time

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation.

impl SubAssign for Duration

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<'a> Sum<&'a Duration> for Duration

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Sum for Duration

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

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 Duration

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