pub struct Duration {
seconds: i64,
nanoseconds: RangedI32<{ _ }, { _ }>,
padding: Padding,
}
Expand description
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§
source§impl Duration
impl Duration
sourcepub const ZERO: Self = _
pub const ZERO: Self = _
Equivalent to 0.seconds()
.
assert_eq!(Duration::ZERO, 0.seconds());
Runsourcepub const NANOSECOND: Self = _
pub const NANOSECOND: Self = _
Equivalent to 1.nanoseconds()
.
assert_eq!(Duration::NANOSECOND, 1.nanoseconds());
Runsourcepub const MICROSECOND: Self = _
pub const MICROSECOND: Self = _
Equivalent to 1.microseconds()
.
assert_eq!(Duration::MICROSECOND, 1.microseconds());
Runsourcepub const MILLISECOND: Self = _
pub const MILLISECOND: Self = _
Equivalent to 1.milliseconds()
.
assert_eq!(Duration::MILLISECOND, 1.milliseconds());
Runsourcepub const SECOND: Self = _
pub const SECOND: Self = _
Equivalent to 1.seconds()
.
assert_eq!(Duration::SECOND, 1.seconds());
Runsourcepub const MINUTE: Self = _
pub const MINUTE: Self = _
Equivalent to 1.minutes()
.
assert_eq!(Duration::MINUTE, 1.minutes());
Runsourcepub const MIN: Self = _
pub const MIN: Self = _
The minimum possible duration. Adding any negative duration to this will cause an overflow.
sourcepub const MAX: Self = _
pub const MAX: Self = _
The maximum possible duration. Adding any positive duration to this will cause an overflow.
sourcepub const fn is_zero(self) -> bool
pub const fn is_zero(self) -> bool
Check if a duration is exactly zero.
assert!(0.seconds().is_zero());
assert!(!1.nanoseconds().is_zero());
Runsourcepub const fn is_negative(self) -> bool
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());
Runsourcepub const fn is_positive(self) -> bool
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());
Runsourcepub const fn abs(self) -> Self
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());
Runsourcepub const fn unsigned_abs(self) -> StdDuration
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());
Runsourcepub(crate) const unsafe fn new_unchecked(seconds: i64, nanoseconds: i32) -> Self
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.
sourcepub(crate) const fn new_ranged_unchecked(
seconds: i64,
nanoseconds: RangedI32<{ _ }, { _ }>,
) -> Self
pub(crate) const fn new_ranged_unchecked( seconds: i64, nanoseconds: RangedI32<{ _ }, { _ }>, ) -> Self
Create a new Duration
without checking the validity of the components.
sourcepub const fn new(seconds: i64, nanoseconds: i32) -> Self
pub const fn new(seconds: i64, nanoseconds: i32) -> Self
Create a new Duration
with the provided seconds and nanoseconds. If nanoseconds is at
least ±109, 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());
Run§Panics
This may panic if an overflow occurs.
sourcepub(crate) const fn new_ranged(
seconds: i64,
nanoseconds: RangedI32<{ _ }, { _ }>,
) -> Self
pub(crate) const fn new_ranged( seconds: i64, nanoseconds: RangedI32<{ _ }, { _ }>, ) -> Self
Create a new Duration
with the provided seconds and nanoseconds.
sourcepub const fn seconds(seconds: i64) -> Self
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());
Runsourcepub fn seconds_f64(seconds: f64) -> Self
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());
Runsourcepub fn seconds_f32(seconds: f32) -> Self
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());
Runsourcepub fn saturating_seconds_f64(seconds: f64) -> Self
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,
);
Runsourcepub fn saturating_seconds_f32(seconds: f32) -> Self
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,
);
Runsourcepub fn checked_seconds_f64(seconds: f64) -> Option<Self>
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);
Runsourcepub fn checked_seconds_f32(seconds: f32) -> Option<Self>
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);
Runsourcepub const fn milliseconds(milliseconds: i64) -> Self
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());
Runsourcepub const fn microseconds(microseconds: i64) -> Self
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());
Runsourcepub const fn nanoseconds(nanoseconds: i64) -> Self
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);
Runsourcepub(crate) const fn nanoseconds_i128(nanoseconds: i128) -> Self
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.
sourcepub const fn whole_weeks(self) -> i64
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);
Runsourcepub const fn whole_days(self) -> i64
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);
Runsourcepub const fn whole_hours(self) -> i64
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);
Runsourcepub const fn whole_minutes(self) -> i64
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);
Runsourcepub const fn whole_seconds(self) -> i64
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);
Runsourcepub fn as_seconds_f64(self) -> f64
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);
Runsourcepub fn as_seconds_f32(self) -> f32
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);
Runsourcepub const fn whole_milliseconds(self) -> i128
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);
Runsourcepub const fn subsec_milliseconds(self) -> i16
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);
Runsourcepub const fn whole_microseconds(self) -> i128
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);
Runsourcepub const fn subsec_microseconds(self) -> i32
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);
Runsourcepub const fn whole_nanoseconds(self) -> i128
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);
Runsourcepub const fn subsec_nanoseconds(self) -> i32
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);
Runsourcepub const fn checked_add(self, rhs: Self) -> Option<Self>
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()));
Runsourcepub const fn checked_sub(self, rhs: Self) -> Option<Self>
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()));
Runsourcepub const fn checked_mul(self, rhs: i32) -> Option<Self>
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);
Runsourcepub const fn checked_div(self, rhs: i32) -> Option<Self>
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);
Runsourcepub const fn checked_neg(self) -> Option<Self>
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);
Runsourcepub const fn saturating_add(self, rhs: Self) -> Self
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);
Runsourcepub const fn saturating_sub(self, rhs: Self) -> Self
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());
Runsourcepub const fn saturating_mul(self, rhs: i32) -> Self
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);
RunTrait Implementations§
source§impl Add<Duration> for OffsetDateTime
impl Add<Duration> for OffsetDateTime
source§impl Add<Duration> for PrimitiveDateTime
impl Add<Duration> for PrimitiveDateTime
source§impl Add<Duration> for SystemTime
impl Add<Duration> for SystemTime
source§impl AddAssign<Duration> for Date
impl AddAssign<Duration> for Date
source§fn add_assign(&mut self, rhs: Duration)
fn add_assign(&mut self, rhs: Duration)
+=
operation. Read moresource§impl AddAssign<Duration> for Duration
impl AddAssign<Duration> for Duration
source§fn add_assign(&mut self, rhs: Duration)
fn add_assign(&mut self, rhs: Duration)
§Panics
This may panic if the resulting addition cannot be represented.
source§impl AddAssign<Duration> for Duration
impl AddAssign<Duration> for Duration
source§fn add_assign(&mut self, rhs: StdDuration)
fn add_assign(&mut self, rhs: StdDuration)
+=
operation. Read moresource§impl AddAssign<Duration> for Instant
impl AddAssign<Duration> for Instant
source§fn add_assign(&mut self, rhs: Duration)
fn add_assign(&mut self, rhs: Duration)
+=
operation. Read moresource§impl AddAssign<Duration> for Instant
impl AddAssign<Duration> for Instant
source§fn add_assign(&mut self, rhs: Duration)
fn add_assign(&mut self, rhs: Duration)
+=
operation. Read moresource§impl AddAssign<Duration> for OffsetDateTime
impl AddAssign<Duration> for OffsetDateTime
source§fn add_assign(&mut self, rhs: Duration)
fn add_assign(&mut self, rhs: Duration)
§Panics
This may panic if an overflow occurs.
source§impl AddAssign<Duration> for PrimitiveDateTime
impl AddAssign<Duration> for PrimitiveDateTime
source§fn add_assign(&mut self, duration: Duration)
fn add_assign(&mut self, duration: Duration)
§Panics
This may panic if an overflow occurs.
source§impl AddAssign<Duration> for SystemTime
impl AddAssign<Duration> for SystemTime
source§fn add_assign(&mut self, rhs: Duration)
fn add_assign(&mut self, rhs: Duration)
+=
operation. Read moresource§impl AddAssign<Duration> for Time
impl AddAssign<Duration> for Time
source§fn add_assign(&mut self, rhs: Duration)
fn add_assign(&mut self, rhs: Duration)
+=
operation. Read moresource§impl AddAssign for Duration
impl AddAssign for Duration
source§fn add_assign(&mut self, rhs: Self)
fn add_assign(&mut self, rhs: Self)
+=
operation. Read moresource§impl<'a> Deserialize<'a> for Duration
impl<'a> Deserialize<'a> for Duration
source§fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error>
fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error>
source§impl Display for Duration
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}");
RunFor the purposes of this implementation, a day is exactly 24 hours and a minute is exactly 60 seconds.
source§impl DivAssign<f32> for Duration
impl DivAssign<f32> for Duration
source§fn div_assign(&mut self, rhs: f32)
fn div_assign(&mut self, rhs: f32)
/=
operation. Read moresource§impl DivAssign<f64> for Duration
impl DivAssign<f64> for Duration
source§fn div_assign(&mut self, rhs: f64)
fn div_assign(&mut self, rhs: f64)
/=
operation. Read moresource§impl DivAssign<i16> for Duration
impl DivAssign<i16> for Duration
source§fn div_assign(&mut self, rhs: i16)
fn div_assign(&mut self, rhs: i16)
/=
operation. Read moresource§impl DivAssign<i32> for Duration
impl DivAssign<i32> for Duration
source§fn div_assign(&mut self, rhs: i32)
fn div_assign(&mut self, rhs: i32)
/=
operation. Read moresource§impl DivAssign<i8> for Duration
impl DivAssign<i8> for Duration
source§fn div_assign(&mut self, rhs: i8)
fn div_assign(&mut self, rhs: i8)
/=
operation. Read moresource§impl DivAssign<u16> for Duration
impl DivAssign<u16> for Duration
source§fn div_assign(&mut self, rhs: u16)
fn div_assign(&mut self, rhs: u16)
/=
operation. Read moresource§impl DivAssign<u32> for Duration
impl DivAssign<u32> for Duration
source§fn div_assign(&mut self, rhs: u32)
fn div_assign(&mut self, rhs: u32)
/=
operation. Read moresource§impl DivAssign<u8> for Duration
impl DivAssign<u8> for Duration
source§fn div_assign(&mut self, rhs: u8)
fn div_assign(&mut self, rhs: u8)
/=
operation. Read moresource§impl MulAssign<f32> for Duration
impl MulAssign<f32> for Duration
source§fn mul_assign(&mut self, rhs: f32)
fn mul_assign(&mut self, rhs: f32)
*=
operation. Read moresource§impl MulAssign<f64> for Duration
impl MulAssign<f64> for Duration
source§fn mul_assign(&mut self, rhs: f64)
fn mul_assign(&mut self, rhs: f64)
*=
operation. Read moresource§impl MulAssign<i16> for Duration
impl MulAssign<i16> for Duration
source§fn mul_assign(&mut self, rhs: i16)
fn mul_assign(&mut self, rhs: i16)
*=
operation. Read moresource§impl MulAssign<i32> for Duration
impl MulAssign<i32> for Duration
source§fn mul_assign(&mut self, rhs: i32)
fn mul_assign(&mut self, rhs: i32)
*=
operation. Read moresource§impl MulAssign<i8> for Duration
impl MulAssign<i8> for Duration
source§fn mul_assign(&mut self, rhs: i8)
fn mul_assign(&mut self, rhs: i8)
*=
operation. Read moresource§impl MulAssign<u16> for Duration
impl MulAssign<u16> for Duration
source§fn mul_assign(&mut self, rhs: u16)
fn mul_assign(&mut self, rhs: u16)
*=
operation. Read moresource§impl MulAssign<u32> for Duration
impl MulAssign<u32> for Duration
source§fn mul_assign(&mut self, rhs: u32)
fn mul_assign(&mut self, rhs: u32)
*=
operation. Read moresource§impl MulAssign<u8> for Duration
impl MulAssign<u8> for Duration
source§fn mul_assign(&mut self, rhs: u8)
fn mul_assign(&mut self, rhs: u8)
*=
operation. Read moresource§impl Ord for Duration
impl Ord for Duration
source§impl PartialEq<Duration> for Duration
impl PartialEq<Duration> for Duration
source§impl PartialEq<Duration> for Duration
impl PartialEq<Duration> for Duration
source§fn eq(&self, rhs: &StdDuration) -> bool
fn eq(&self, rhs: &StdDuration) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl PartialEq for Duration
impl PartialEq for Duration
source§impl PartialOrd<Duration> for Duration
impl PartialOrd<Duration> for Duration
source§fn partial_cmp(&self, rhs: &StdDuration) -> Option<Ordering>
fn partial_cmp(&self, rhs: &StdDuration) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd<Duration> for Duration
impl PartialOrd<Duration> for Duration
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl PartialOrd for Duration
impl PartialOrd for Duration
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl Sub<Duration> for OffsetDateTime
impl Sub<Duration> for OffsetDateTime
source§impl Sub<Duration> for PrimitiveDateTime
impl Sub<Duration> for PrimitiveDateTime
source§impl Sub<Duration> for SystemTime
impl Sub<Duration> for SystemTime
source§impl SubAssign<Duration> for Date
impl SubAssign<Duration> for Date
source§fn sub_assign(&mut self, rhs: Duration)
fn sub_assign(&mut self, rhs: Duration)
-=
operation. Read moresource§impl SubAssign<Duration> for Duration
impl SubAssign<Duration> for Duration
source§fn sub_assign(&mut self, rhs: StdDuration)
fn sub_assign(&mut self, rhs: StdDuration)
-=
operation. Read moresource§impl SubAssign<Duration> for Duration
impl SubAssign<Duration> for Duration
source§fn sub_assign(&mut self, rhs: Duration)
fn sub_assign(&mut self, rhs: Duration)
§Panics
This may panic if the resulting subtraction can not be represented.
source§impl SubAssign<Duration> for Instant
impl SubAssign<Duration> for Instant
source§fn sub_assign(&mut self, rhs: Duration)
fn sub_assign(&mut self, rhs: Duration)
-=
operation. Read moresource§impl SubAssign<Duration> for Instant
impl SubAssign<Duration> for Instant
source§fn sub_assign(&mut self, rhs: Duration)
fn sub_assign(&mut self, rhs: Duration)
-=
operation. Read moresource§impl SubAssign<Duration> for OffsetDateTime
impl SubAssign<Duration> for OffsetDateTime
source§fn sub_assign(&mut self, rhs: Duration)
fn sub_assign(&mut self, rhs: Duration)
§Panics
This may panic if an overflow occurs.
source§impl SubAssign<Duration> for PrimitiveDateTime
impl SubAssign<Duration> for PrimitiveDateTime
source§fn sub_assign(&mut self, duration: Duration)
fn sub_assign(&mut self, duration: Duration)
§Panics
This may panic if an overflow occurs.
source§impl SubAssign<Duration> for SystemTime
impl SubAssign<Duration> for SystemTime
source§fn sub_assign(&mut self, rhs: Duration)
fn sub_assign(&mut self, rhs: Duration)
-=
operation. Read moresource§impl SubAssign<Duration> for Time
impl SubAssign<Duration> for Time
source§fn sub_assign(&mut self, rhs: Duration)
fn sub_assign(&mut self, rhs: Duration)
-=
operation. Read moresource§impl SubAssign for Duration
impl SubAssign for Duration
source§fn sub_assign(&mut self, rhs: Self)
fn sub_assign(&mut self, rhs: Self)
-=
operation. Read more