Struct time::Duration

pub struct Duration { /* private fields */ }

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.

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 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 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 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 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: Duration)

Panics

This may panic if the resulting addition cannot be represented.

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

Restrict a value to a certain interval.

impl PartialEq<Duration> for Duration

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. 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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for Duration

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl 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

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

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

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

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

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

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

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

impl PartialOrd<Duration> for Duration

fn partial_cmp(&self, rhs: &StdDuration) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

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

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

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

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

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

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

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

impl PartialOrd for Duration

fn partial_cmp(&self, other: &Duration) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

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

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

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

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

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

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

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

impl 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: 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 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 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 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 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

Method which 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

Method which 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(duration: Duration) -> 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(original: StdDuration) -> Result<Self, ConversionRange>

Performs the conversion.

impl Copy for Duration

impl Eq for Duration

impl StructuralPartialEq for Duration